{

std::unordered_set<NodeId> nodeIds;

for_each(_models.begin(), _models.end(), [&nodeIds](auto const &p) { nodeIds.insert(p.first); });

return nodeIds;

{

std::unordered_set<ConnectionId> result;

std::copy_if(_connectivity.begin(),

_connectivity.end(),

std::inserter(result, std::end(result)),

[&nodeId](ConnectionId const &cid) {

return cid.inNodeId == nodeId || cid.outNodeId == nodeId;

});

return result;

PortType portType,

PortIndex portIndex) const

{

std::unordered_set<ConnectionId> result;

std::copy_if(_connectivity.begin(),

_connectivity.end(),

std::inserter(result, std::end(result)),

[&portType, &portIndex, &nodeId](ConnectionId const &cid) {

return (getNodeId(portType, cid) == nodeId

&& getPortIndex(portType, cid) == portIndex);

});

return result;

{

std::unique_ptr<NodeDelegateModel> model = _registry->create(nodeType);

if (model) {

NodeId newId = newNodeId();

connect(model.get(),

&NodeDelegateModel::dataUpdated,

[newId, this](PortIndex const portIndex) {

onOutPortDataUpdated(newId, portIndex);

});

connect(model.get(),

&NodeDelegateModel::portsAboutToBeDeleted,

this,

[newId, this](PortType const portType, PortIndex const first, PortIndex const last) {

portsAboutToBeDeleted(newId, portType, first, last);

});

connect(model.get(),

&NodeDelegateModel::portsDeleted,

this,

&DataFlowGraphModel::portsDeleted);

connect(model.get(),

&NodeDelegateModel::portsAboutToBeInserted,

this,

[newId, this](PortType const portType, PortIndex const first, PortIndex const last) {

portsAboutToBeInserted(newId, portType, first, last);

});

connect(model.get(),

&NodeDelegateModel::portsInserted,

this,

&DataFlowGraphModel::portsInserted);

connect(model.get(), &NodeDelegateModel::requestNodeUpdate, this, [newId, this]() {

Q_EMIT nodeUpdated(newId);

});

_models[newId] = std::move(model);

_labels[newId] = _models[newId]->label();

_labelsVisible[newId] = _models[newId]->labelVisible();

Q_EMIT nodeCreated(newId);

return newId;

}

return InvalidNodeId;

{

// Check if nodes exist

if (!nodeExists(connectionId.outNodeId) || !nodeExists(connectionId.inNodeId)) {

return false;

}

// Check port bounds, i.e. that we do not connect non-existing port numbers

auto checkPortBounds = [&](PortType const portType) {

NodeId const nodeId = getNodeId(portType, connectionId);

auto portCountRole = (portType == PortType::Out) ? NodeRole::OutPortCount

: NodeRole::InPortCount;

std::size_t const portCount = nodeData(nodeId, portCountRole).toUInt();

return getPortIndex(portType, connectionId) < portCount;

};

auto getDataType = [&](PortType const portType) {

return portData(getNodeId(portType, connectionId),

portType,

getPortIndex(portType, connectionId),

PortRole::DataType)

.value<NodeDataType>();

};

auto portVacant = [&](PortType const portType) {

NodeId const nodeId = getNodeId(portType, connectionId);

PortIndex const portIndex = getPortIndex(portType, connectionId);

auto const connected = connections(nodeId, portType, portIndex);

auto policy = portData(nodeId, portType, portIndex, PortRole::ConnectionPolicyRole)

.value<ConnectionPolicy>();

return connected.empty() || (policy == ConnectionPolicy::Many);

};

bool const basicChecks = getDataType(PortType::Out).id == getDataType(PortType::In).id

&& portVacant(PortType::Out) && portVacant(PortType::In)

&& checkPortBounds(PortType::Out) && checkPortBounds(PortType::In);

// In data-flow mode (this class) it's important to forbid graph loops.

// We perform depth-first graph traversal starting from the "Input" port of

// the given connection. We should never encounter the starting "Out" node.

auto hasLoops = [this, &connectionId]() -> bool {

std::stack<NodeId> filo;

filo.push(connectionId.inNodeId);

while (!filo.empty()) {

auto id = filo.top();

filo.pop();

if (id == connectionId.outNodeId) { // LOOP!

return true;

}

// Add out-connections to continue interations

std::size_t const nOutPorts = nodeData(id, NodeRole::OutPortCount).toUInt();

for (PortIndex index = 0; index < nOutPorts; ++index) {

auto const &outConnectionIds = connections(id, PortType::Out, index);

for (auto cid : outConnectionIds) {

filo.push(cid.inNodeId);

}

}

}

return false;

};

return basicChecks && (loopsEnabled() || !hasLoops());

{

_connectivity.insert(connectionId);

sendConnectionCreation(connectionId);

QVariant const portDataToPropagate = portData(connectionId.outNodeId,

PortType::Out,

connectionId.outPortIndex,

PortRole::Data);

setPortData(connectionId.inNodeId,

PortType::In,

connectionId.inPortIndex,

portDataToPropagate,

PortRole::Data);

{

Q_EMIT connectionCreated(connectionId);

auto iti = _models.find(connectionId.inNodeId);

auto ito = _models.find(connectionId.outNodeId);

if (iti != _models.end() && ito != _models.end()) {

auto &modeli = iti->second;

auto &modelo = ito->second;

modeli->inputConnectionCreated(connectionId);

modelo->outputConnectionCreated(connectionId);

}

{

Q_EMIT connectionDeleted(connectionId);

auto iti = _models.find(connectionId.inNodeId);

auto ito = _models.find(connectionId.outNodeId);

if (iti != _models.end() && ito != _models.end()) {

auto &modeli = iti->second;

auto &modelo = ito->second;

modeli->inputConnectionDeleted(connectionId);

modelo->outputConnectionDeleted(connectionId);

}

{

QVariant result;

auto it = _models.find(nodeId);

if (it == _models.end())

return result;

auto &model = it->second;

switch (role) {

case NodeRole::Type:

result = model->name();

break;

case NodeRole::Position:

result = _nodeGeometryData[nodeId].pos;

break;

case NodeRole::Size:

result = _nodeGeometryData[nodeId].size;

break;

case NodeRole::CaptionVisible:

result = model->captionVisible();

break;

case NodeRole::Caption:

result = model->caption();

break;

case NodeRole::Style: {

auto style = model->nodeStyle();

result = style.toJson().toVariantMap();

} break;

case NodeRole::InternalData: {

QJsonObject nodeJson;

nodeJson["internal-data"] = model->save();

result = nodeJson.toVariantMap();

break;

}

case NodeRole::InPortCount:

result = model->nPorts(PortType::In);

break;

case NodeRole::OutPortCount:

result = model->nPorts(PortType::Out);

break;

case NodeRole::Widget: {

auto *w = model->embeddedWidget();

result = QVariant::fromValue(w);

} break;

case NodeRole::ValidationState: {

auto validationState = model->validationState();

result = QVariant::fromValue(validationState);

} break;

case NodeRole::LabelVisible: {

auto const labelVisibleIt = _labelsVisible.find(nodeId);

result = (labelVisibleIt != _labelsVisible.end()) ? labelVisibleIt->second

: model->labelVisible();

} break;

case NodeRole::Label: {

auto const labelIt = _labels.find(nodeId);

result = (labelIt != _labels.end()) ? labelIt->second : model->label();

} break;

case NodeRole::LabelEditable:

result = model->labelEditable();

break;

case NodeRole::ProcessingStatus: {

auto processingStatus = model->processingStatus();

result = QVariant::fromValue(processingStatus);

} break;

case NodeRole::ProgressValue:

result = model->progressValue();

break;

}

return result;

{

auto it = _models.find(nodeId);

if (it != _models.end() && it->second->resizable())

return NodeFlag::Resizable;

return NodeFlag::NoFlags;

{

Q_UNUSED(nodeId);

Q_UNUSED(role);

Q_UNUSED(value);

bool result = false;

switch (role) {

case NodeRole::Type:

break;

case NodeRole::Position: {

_nodeGeometryData[nodeId].pos = value.value<QPointF>();

Q_EMIT nodePositionUpdated(nodeId);

result = true;

} break;

case NodeRole::Size: {

_nodeGeometryData[nodeId].size = value.value<QSize>();

result = true;

} break;

case NodeRole::CaptionVisible:

break;

case NodeRole::Caption:

break;

case NodeRole::Style:

break;

case NodeRole::InternalData:

break;

case NodeRole::InPortCount:

break;

case NodeRole::OutPortCount:

break;

case NodeRole::Widget:

break;

case NodeRole::ValidationState: {

if (value.canConvert<NodeValidationState>()) {

auto state = value.value<NodeValidationState>();

if (auto node = delegateModel<NodeDelegateModel>(nodeId); node != nullptr) {

node->setValidationState(state);

}

}

Q_EMIT nodeUpdated(nodeId);

} break;

case NodeRole::ProcessingStatus: {

if (value.canConvert<QtNodes::NodeProcessingStatus>()) {

auto status = value.value<QtNodes::NodeProcessingStatus>();

if (auto node = delegateModel<NodeDelegateModel>(nodeId); node != nullptr) {

node->setNodeProcessingStatus(status);

}

}

Q_EMIT nodeUpdated(nodeId);

} break;

case NodeRole::LabelVisible: {

_labelsVisible[nodeId] = value.toBool();

Q_EMIT nodeUpdated(nodeId);

result = true;

} break;

case NodeRole::Label: {

_labels[nodeId] = value.toString();

Q_EMIT nodeUpdated(nodeId);

result = true;

} break;

case NodeRole::LabelEditable:

break;

case NodeRole::ProgressValue:

break;

}

return result;

PortType portType,

PortIndex portIndex,

PortRole role) const

{

QVariant result;

auto it = _models.find(nodeId);

if (it == _models.end())

return result;

auto &model = it->second;

switch (role) {

case PortRole::Data:

if (portType == PortType::Out) {

result = QVariant::fromValue(model->outData(portIndex));

}

break;

case PortRole::DataType:

result = QVariant::fromValue(model->dataType(portType, portIndex));

break;

case PortRole::ConnectionPolicyRole:

result = QVariant::fromValue(model->portConnectionPolicy(portType, portIndex));

break;

case PortRole::CaptionVisible:

result = model->portCaptionVisible(portType, portIndex);

break;

case PortRole::Caption:

result = model->portCaption(portType, portIndex);

break;

}

return result;

NodeId nodeId, PortType portType, PortIndex portIndex, QVariant const &value, PortRole role)

{

Q_UNUSED(nodeId);

QVariant result;

auto it = _models.find(nodeId);

if (it == _models.end())

return false;

auto &model = it->second;

switch (role) {

case PortRole::Data:

if (portType == PortType::In) {

if (model->frozen())

return false;

model->setInData(value.value<std::shared_ptr<NodeData>>(), portIndex);

// Triggers repainting on the scene.

Q_EMIT inPortDataWasSet(nodeId, portType, portIndex);

}

break;

default:

break;

}

return false;

{

bool disconnected = false;

auto it = _connectivity.find(connectionId);

if (it != _connectivity.end()) {

disconnected = true;

_connectivity.erase(it);

}

if (disconnected) {

sendConnectionDeletion(connectionId);

propagateEmptyDataTo(getNodeId(PortType::In, connectionId),

getPortIndex(PortType::In, connectionId));

}

return disconnected;

{

// Delete connections to this node first.

auto connectionIds = allConnectionIds(nodeId);

for (auto &cId : connectionIds) {

deleteConnection(cId);

}

_nodeGeometryData.erase(nodeId);

_labels.erase(nodeId);

_labelsVisible.erase(nodeId);

_models.erase(nodeId);

Q_EMIT nodeDeleted(nodeId);

return true;

{

QJsonObject nodeJson;

auto const modelIt = _models.find(nodeId);

if (modelIt == _models.end()) {

return nodeJson;

}

auto const &model = modelIt->second;

nodeJson["id"] = static_cast<qint64>(nodeId);

nodeJson["internal-data"] = model->save();

auto const labelIt = _labels.find(nodeId);

nodeJson["label"] = (labelIt != _labels.end()) ? labelIt->second : model->label();

auto const labelVisibleIt = _labelsVisible.find(nodeId);

nodeJson["labelVisible"] = (labelVisibleIt != _labelsVisible.end()) ? labelVisibleIt->second

: model->labelVisible();

{

QPointF const pos = nodeData(nodeId, NodeRole::Position).value<QPointF>();

QJsonObject posJson;

posJson["x"] = pos.x();

posJson["y"] = pos.y();

nodeJson["position"] = posJson;

}

return nodeJson;

{

QJsonObject sceneJson;

QJsonArray nodesJsonArray;

for (auto const nodeId : allNodeIds()) {

nodesJsonArray.append(saveNode(nodeId));

}

sceneJson["nodes"] = nodesJsonArray;

QJsonArray connJsonArray;

for (auto const &cid : _connectivity) {

connJsonArray.append(toJson(cid));

}

sceneJson["connections"] = connJsonArray;

return sceneJson;

{

// Possibility of the id clash when reading it from json and not generating a

// new value.

// 1. When restoring a scene from a file.

// Conflict is not possible because the scene must be cleared by the time of

// loading.

// 2. When undoing the deletion command. Conflict is not possible

// because all the new ids were created past the removed nodes.

NodeId restoredNodeId = nodeJson["id"].toInt();

_nextNodeId = std::max(_nextNodeId, restoredNodeId + 1);

QJsonObject const internalDataJson = nodeJson["internal-data"].toObject();

QString delegateModelName = internalDataJson["model-name"].toString();

std::unique_ptr<NodeDelegateModel> model = _registry->create(delegateModelName);

if (model) {

connect(model.get(),

&NodeDelegateModel::dataUpdated,

[restoredNodeId, this](PortIndex const portIndex) {

onOutPortDataUpdated(restoredNodeId, portIndex);

});

connect(model.get(),

&NodeDelegateModel::portsAboutToBeDeleted,

this,

[restoredNodeId,

this](PortType const portType, PortIndex const first, PortIndex const last) {

portsAboutToBeDeleted(restoredNodeId, portType, first, last);

});

connect(model.get(),

&NodeDelegateModel::portsDeleted,

this,

&DataFlowGraphModel::portsDeleted);

connect(model.get(),

&NodeDelegateModel::portsAboutToBeInserted,

this,

[restoredNodeId,

this](PortType const portType, PortIndex const first, PortIndex const last) {

portsAboutToBeInserted(restoredNodeId, portType, first, last);

});

connect(model.get(),

&NodeDelegateModel::portsInserted,

this,

&DataFlowGraphModel::portsInserted);

connect(model.get(), &NodeDelegateModel::requestNodeUpdate, this, [restoredNodeId, this]() {

Q_EMIT nodeUpdated(restoredNodeId);

});

_models[restoredNodeId] = std::move(model);

Q_EMIT nodeCreated(restoredNodeId);

QJsonObject posJson = nodeJson["position"].toObject();

QPointF const pos(posJson["x"].toDouble(), posJson["y"].toDouble());

setNodeData(restoredNodeId, NodeRole::Position, pos);

auto *restoredModel = _models[restoredNodeId].get();

_labels[restoredNodeId] = nodeJson["label"].toString(restoredModel->label());

_labelsVisible[restoredNodeId] = nodeJson.contains("labelVisible")

? nodeJson["labelVisible"].toBool()

: restoredModel->labelVisible();

restoredModel->load(internalDataJson);

} else {

throw std::logic_error(std::string("No registered model with name ")

+ delegateModelName.toLocal8Bit().data());

}

{

QJsonArray nodesJsonArray = jsonDocument["nodes"].toArray();

for (QJsonValueRef nodeJson : nodesJsonArray) {

loadNode(nodeJson.toObject());

}

QJsonArray connectionJsonArray = jsonDocument["connections"].toArray();

for (QJsonValueRef connection : connectionJsonArray) {

QJsonObject connJson = connection.toObject();

ConnectionId connId = fromJson(connJson);

// Restore the connection

addConnection(connId);

}

{

std::unordered_set<ConnectionId> const &connected = connections(nodeId,

PortType::Out,

portIndex);

QVariant const portDataToPropagate = portData(nodeId, PortType::Out, portIndex, PortRole::Data);

for (auto const &cn : connected) {

setPortData(cn.inNodeId, PortType::In, cn.inPortIndex, portDataToPropagate, PortRole::Data);

}

{

QVariant emptyData{};

setPortData(nodeId, PortType::In, portIndex, emptyData, PortRole::Data);