1071 lines
34 KiB
C++
1071 lines
34 KiB
C++
#include <QJsonArray>
|
||
#include <QJsonDocument>
|
||
#include "topologyManager.h"
|
||
#include "powerEntity.h"
|
||
#include "graphicsItem/graphicsBaseItem.h"
|
||
|
||
TopologyManager& TopologyManager::instance()
|
||
{
|
||
static TopologyManager instance;
|
||
return instance;
|
||
}
|
||
|
||
TopologyManager::TopologyManager(QObject* parent)
|
||
: QObject(parent) {}
|
||
|
||
TopologyManager::~TopologyManager() {
|
||
clearAllData();
|
||
}
|
||
|
||
void TopologyManager::clearAllData()
|
||
{
|
||
// 删除所有连接
|
||
qDeleteAll(m_connections);
|
||
m_connections.clear();
|
||
m_connectionIndex.clear();
|
||
// 删除所有实体（自动删除子对象）
|
||
qDeleteAll(m_entities);
|
||
m_entities.clear();
|
||
m_allTerminals.clear(); //端点由父亲entity释放
|
||
|
||
// 删除所有连接
|
||
qDeleteAll(m_baseConnections);
|
||
m_baseConnections.clear();
|
||
m_baseConnectionIndex.clear();
|
||
// 删除所有实体（自动删除子对象）
|
||
qDeleteAll(m_baseEntities);
|
||
m_baseEntities.clear();
|
||
m_baseAllTerminals.clear(); //端点由父亲entity释放
|
||
|
||
// 删除所有连接
|
||
qDeleteAll(m_editorConnections);
|
||
m_editorConnections.clear();
|
||
m_editorConnectionIndex.clear();
|
||
// 删除所有实体（自动删除子对象）
|
||
qDeleteAll(m_editorEntities);
|
||
m_editorEntities.clear();
|
||
m_editorAllTerminals.clear(); //端点由父亲entity释放
|
||
|
||
qDeleteAll(m_blockConnections);
|
||
m_blockConnections.clear();
|
||
m_blockConnectionIndex.clear();
|
||
// 删除所有实体（自动删除子对象）
|
||
qDeleteAll(m_blockEntities);
|
||
m_blockEntities.clear();
|
||
m_blockAllTerminals.clear(); //端点由父亲entity释放
|
||
}
|
||
|
||
PowerEntity* TopologyManager::createEntity(EntityType type,const QString& uuid, const QString& name,ModelFunctionType funType,const QString& block)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
{
|
||
PowerEntity* entity = nullptr;
|
||
switch(type) {
|
||
case EntityType::Grid:
|
||
case EntityType::Zone:
|
||
case EntityType::Station:
|
||
entity = new PowerDivision(type, uuid,name);
|
||
default:
|
||
entity = new PowerComponent(type, uuid,name);
|
||
}
|
||
|
||
if(entity == nullptr)
|
||
return nullptr;
|
||
|
||
m_entities.insert(entity->id(), entity);
|
||
emit entityCreated(entity->id()); // 发送信号通知
|
||
return entity;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
{
|
||
PowerEntity* entity = nullptr;
|
||
entity = new PowerComponent(type, uuid,name);
|
||
|
||
m_baseEntities.insert(entity->id(), entity);
|
||
emit entityCreated(entity->id()); // 发送信号通知
|
||
return entity;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
{
|
||
PowerEntity* entity = nullptr;
|
||
entity = new PowerComponent(type, uuid,name);
|
||
|
||
m_editorEntities.insert(entity->id(), entity);
|
||
return entity;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
{
|
||
PowerEntity* entity = nullptr;
|
||
entity = new PowerComponent(type, uuid,name);
|
||
entity->setBlock(block);
|
||
|
||
m_blockEntities.insert(entity->id(), entity);
|
||
return entity;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
PowerEntity* TopologyManager::findEntity(const QString& id,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_entities.value(id, nullptr); // 避免异常的安全查询
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseEntities.value(id, nullptr);
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
return m_editorEntities.value(id, nullptr);
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
return m_blockEntities.value(id, nullptr);
|
||
return nullptr;
|
||
}
|
||
|
||
bool TopologyManager::deleteEntity(const QString& id,ModelFunctionType funType)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
{
|
||
if (!m_entities.contains(id)) return false;
|
||
|
||
PowerEntity* entity = m_entities[id];
|
||
|
||
// 步骤1：删除所有相关连接
|
||
auto relatedConns = getConnectionsFor(id);
|
||
|
||
for (auto conn : relatedConns) {
|
||
removeConnection(conn->id());
|
||
}
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteEntity(child->id()); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_entities.remove(id);
|
||
delete entity; // 触发PowerEntity析构函数
|
||
|
||
emit entityDeleted(id);
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
{
|
||
if (!m_baseEntities.contains(id)) return false;
|
||
PowerEntity* entity = m_baseEntities[id];
|
||
|
||
// 步骤1：删除所有相关连接
|
||
auto relatedConns = getConnectionsFor(id,funType);
|
||
for (auto conn : relatedConns) {
|
||
removeConnection(conn->id(),funType);
|
||
}
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteEntity(child->id(),funType); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_baseEntities.remove(id);
|
||
delete entity; // 触发PowerEntity析构函数
|
||
|
||
emit entityDeleted(id);
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
{
|
||
if (!m_editorEntities.contains(id)) return false;
|
||
PowerEntity* entity = m_editorEntities[id];
|
||
|
||
// 步骤1：删除所有相关连接
|
||
auto relatedConns = getConnectionsFor(id,funType);
|
||
for (auto conn : relatedConns) {
|
||
removeConnection(conn->id(),funType);
|
||
}
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteEntity(child->id(),funType); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_editorEntities.remove(id);
|
||
delete entity; // 触发PowerEntity析构函数
|
||
|
||
emit entityDeleted(id);
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
{
|
||
if (!m_blockEntities.contains(id)) return false;
|
||
PowerEntity* entity = m_blockEntities[id];
|
||
|
||
// 步骤1：删除所有相关连接
|
||
auto relatedConns = getConnectionsFor(id,funType);
|
||
for (auto conn : relatedConns) {
|
||
removeConnection(conn->id(),funType);
|
||
}
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteEntity(child->id(),funType); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_blockEntities.remove(id);
|
||
delete entity; // 触发PowerEntity析构函数
|
||
|
||
emit entityDeleted(id);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
QList<PowerEntity*> TopologyManager::getEntitiesByBlock(const QString& str)
|
||
{
|
||
QList<PowerEntity*> lst;
|
||
for(auto& entity:m_blockEntities){
|
||
if(entity->block() == str){
|
||
lst.append(entity);
|
||
}
|
||
}
|
||
return lst;
|
||
}
|
||
|
||
void TopologyManager::moveTempBlockData()
|
||
{
|
||
auto tempEntities = std::move(m_blockEntities);
|
||
m_editorEntities.insert(tempEntities);
|
||
|
||
auto tempConnections = std::move(m_blockConnections);
|
||
m_editorConnections.insert(tempConnections);
|
||
|
||
auto tempConIndex = std::move(m_blockConnectionIndex);
|
||
m_editorConnectionIndex.unite(tempConIndex);
|
||
|
||
auto tempTer = std::move(m_blockAllTerminals);
|
||
m_editorAllTerminals.insert(tempTer);
|
||
|
||
auto tempEntityTer = std::move(m_blockTerminalsByEntity);
|
||
m_editorTerminalsByEntity.insert(tempEntityTer);
|
||
|
||
auto tempEntityCon = std::move(m_blockEntityConnections);
|
||
m_editorEntityConnections.insert(tempEntityCon);
|
||
}
|
||
|
||
void TopologyManager::clearGlobalBlockData(const QString& sName)
|
||
{
|
||
QList<PowerEntity*> lst = getEntitiesByBlock(sName);
|
||
for(auto p:lst){
|
||
deleteEntity(p->id(),ModelFunctionType::EditorModel);
|
||
}
|
||
}
|
||
|
||
PowerConnection* TopologyManager::createConnection(const QString& connId,const QString& fromTerId, const QString& toTerId,const QString& fromId,const QString& toId,ModelFunctionType funType)
|
||
{
|
||
PowerConnection* conn = nullptr;
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
{
|
||
// 验证有效性
|
||
if (!m_allTerminals.contains(fromTerId) ||
|
||
!m_allTerminals.contains(toTerId) ||
|
||
fromTerId == toTerId)
|
||
{
|
||
qWarning() << "Invalid connection endpoints";
|
||
return nullptr;
|
||
}
|
||
|
||
// 防止重复连接
|
||
foreach (auto conn, m_connections) {
|
||
if (conn->fromTerminalId() == fromTerId &&
|
||
conn->toTerminalId() == toTerId)
|
||
{
|
||
return conn; // 返回已存在的连接
|
||
}
|
||
}
|
||
|
||
// 创建新连接
|
||
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
|
||
m_connections[connId] = conn;
|
||
|
||
// 更新索引
|
||
m_connectionIndex.insert(fromTerId, conn);
|
||
m_connectionIndex.insert(toTerId, conn);
|
||
|
||
emit connectionCreated(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
{
|
||
// 验证有效性
|
||
if (!m_baseAllTerminals.contains(fromTerId) ||
|
||
!m_baseAllTerminals.contains(toTerId) ||
|
||
fromTerId == toTerId)
|
||
{
|
||
qWarning() << "Invalid connection endpoints";
|
||
return nullptr;
|
||
}
|
||
|
||
// 防止重复连接
|
||
foreach (auto conn, m_baseConnections) {
|
||
if (conn->fromTerminalId() == fromTerId &&
|
||
conn->toTerminalId() == toTerId)
|
||
{
|
||
return conn; // 返回已存在的连接
|
||
}
|
||
}
|
||
|
||
// 创建新连接
|
||
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
|
||
m_baseConnections[connId] = conn;
|
||
|
||
// 更新索引
|
||
m_baseConnectionIndex.insert(fromTerId, conn);
|
||
m_baseConnectionIndex.insert(toTerId, conn);
|
||
|
||
emit connectionCreated(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
{
|
||
// 验证有效性
|
||
if (!m_editorAllTerminals.contains(fromTerId) ||
|
||
!m_editorAllTerminals.contains(toTerId) ||
|
||
fromTerId == toTerId)
|
||
{
|
||
qWarning() << "Invalid connection endpoints";
|
||
return nullptr;
|
||
}
|
||
|
||
// 防止重复连接
|
||
foreach (auto conn, m_editorConnections) {
|
||
if (conn->fromTerminalId() == fromTerId &&
|
||
conn->toTerminalId() == toTerId)
|
||
{
|
||
return conn; // 返回已存在的连接
|
||
}
|
||
}
|
||
|
||
// 创建新连接
|
||
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
|
||
m_editorConnections[connId] = conn;
|
||
|
||
// 更新索引
|
||
m_editorConnectionIndex.insert(fromTerId, conn);
|
||
m_editorConnectionIndex.insert(toTerId, conn);
|
||
|
||
emit connectionCreated(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
{
|
||
// 验证有效性
|
||
if (!m_blockAllTerminals.contains(fromTerId) ||
|
||
!m_blockAllTerminals.contains(toTerId) ||
|
||
fromTerId == toTerId)
|
||
{
|
||
qWarning() << "Invalid connection endpoints";
|
||
return nullptr;
|
||
}
|
||
|
||
// 防止重复连接
|
||
foreach (auto conn, m_blockConnections) {
|
||
if (conn->fromTerminalId() == fromTerId &&
|
||
conn->toTerminalId() == toTerId)
|
||
{
|
||
return conn; // 返回已存在的连接
|
||
}
|
||
}
|
||
|
||
// 创建新连接
|
||
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
|
||
m_blockConnections[connId] = conn;
|
||
|
||
// 更新索引
|
||
m_blockConnectionIndex.insert(fromTerId, conn);
|
||
m_blockConnectionIndex.insert(toTerId, conn);
|
||
|
||
emit connectionCreated(connId);
|
||
}
|
||
return conn;
|
||
}
|
||
|
||
QList<PowerConnection*> TopologyManager::getConnectionsForTerminal(const QString& terminalId,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_connectionIndex.values(terminalId);
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseConnectionIndex.values(terminalId);
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
return m_editorConnectionIndex.values(terminalId);
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
return m_blockConnectionIndex.values(terminalId);
|
||
return QList<PowerConnection*>();
|
||
}
|
||
|
||
void TopologyManager::removeConnection(const QString& connId,ModelFunctionType funType)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
if (!m_connections.contains(connId)) return;
|
||
|
||
PowerConnection* conn = m_connections[connId];
|
||
|
||
// 更新索引
|
||
m_connectionIndex.remove(conn->fromTerminalId(), conn);
|
||
m_connectionIndex.remove(conn->toTerminalId(), conn);
|
||
|
||
// 清理内存
|
||
m_connections.remove(connId);
|
||
delete conn;
|
||
|
||
emit connectionRemoved(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
if (!m_baseConnections.contains(connId)) return;
|
||
|
||
PowerConnection* conn = m_baseConnections[connId];
|
||
|
||
// 更新索引
|
||
m_baseConnectionIndex.remove(conn->fromTerminalId(), conn);
|
||
m_baseConnectionIndex.remove(conn->toTerminalId(), conn);
|
||
|
||
// 清理内存
|
||
m_baseConnections.remove(connId);
|
||
delete conn;
|
||
|
||
emit connectionRemoved(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
if (!m_editorConnections.contains(connId)) return;
|
||
|
||
PowerConnection* conn = m_editorConnections[connId];
|
||
|
||
// 更新索引
|
||
m_editorConnectionIndex.remove(conn->fromTerminalId(), conn);
|
||
m_editorConnectionIndex.remove(conn->toTerminalId(), conn);
|
||
|
||
// 清理内存
|
||
m_editorConnections.remove(connId);
|
||
delete conn;
|
||
|
||
emit connectionRemoved(connId);
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
if (!m_blockConnections.contains(connId)) return;
|
||
|
||
PowerConnection* conn = m_blockConnections[connId];
|
||
|
||
// 更新索引
|
||
m_blockConnectionIndex.remove(conn->fromTerminalId(), conn);
|
||
m_blockConnectionIndex.remove(conn->toTerminalId(), conn);
|
||
|
||
// 清理内存
|
||
m_blockConnections.remove(connId);
|
||
delete conn;
|
||
|
||
emit connectionRemoved(connId);
|
||
}
|
||
}
|
||
|
||
bool TopologyManager::validateConnection(const QString& fromTermId, const QString& toTermId,ModelFunctionType funType) const
|
||
{
|
||
PowerTerminal* fromTerm = nullptr;
|
||
PowerTerminal* toTerm = nullptr;
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
fromTerm = getTerminal(fromTermId);
|
||
toTerm = getTerminal(toTermId);
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
fromTerm = getTerminal(fromTermId,funType);
|
||
toTerm = getTerminal(toTermId,funType);
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
fromTerm = getTerminal(fromTermId,funType);
|
||
toTerm = getTerminal(toTermId,funType);
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
fromTerm = getTerminal(fromTermId,funType);
|
||
toTerm = getTerminal(toTermId,funType);
|
||
}
|
||
|
||
if (!fromTerm || !toTerm) return false;
|
||
// 类型兼容性检查（示例规则）
|
||
switch(fromTerm->type()) {
|
||
case TerminalType::PowerOutput:
|
||
if (toTerm->type() != TerminalType::PowerInput && toTerm->type() != TerminalType::PowerConnect) return false;
|
||
break;
|
||
case TerminalType::PowerInput:
|
||
if (toTerm->type() != TerminalType::PowerOutput && toTerm->type() != TerminalType::PowerConnect) return false;
|
||
break;
|
||
case TerminalType::PowerConnect:
|
||
break;
|
||
case TerminalType::ControlSignal:
|
||
if (toTerm->type() != TerminalType::ControlSignal) return false;
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
|
||
// 禁止自连接
|
||
return (fromTerm->parentEntityId() != toTerm->parentEntityId());
|
||
|
||
}
|
||
|
||
QList<PowerConnection*> TopologyManager::getConnectionsFor(const QString& entityId,ModelFunctionType funType) const
|
||
{
|
||
QList<PowerConnection*> lst;
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
{
|
||
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId);
|
||
for(auto &terminal:lstTerminal)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id());
|
||
if(con)
|
||
lst.append(con);
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
{
|
||
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId,funType);
|
||
for(auto &terminal:lstTerminal)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
|
||
if(con)
|
||
lst.append(con);
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
{
|
||
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId,funType);
|
||
for(auto &terminal:lstTerminal)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
|
||
if(con)
|
||
lst.append(con);
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
{
|
||
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId,funType);
|
||
for(auto &terminal:lstTerminal)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
|
||
if(con)
|
||
lst.append(con);
|
||
}
|
||
}
|
||
return lst;
|
||
}
|
||
|
||
PowerConnection* TopologyManager::connection(const QString& conId,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_connections.value(conId,nullptr);
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseConnections.value(conId,nullptr);
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
return m_editorConnections.value(conId,nullptr);
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
return m_blockConnections.value(conId,nullptr);
|
||
return nullptr;
|
||
}
|
||
|
||
PowerConnection* TopologyManager::connection(const QString& fromPin,const QString& toPin,ModelFunctionType funType)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
for(auto &con:m_connections)
|
||
{
|
||
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
|
||
return con;
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
for(auto &con:m_baseConnections)
|
||
{
|
||
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
|
||
return con;
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
for(auto &con:m_editorConnections)
|
||
{
|
||
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
|
||
return con;
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
for(auto &con:m_blockConnections)
|
||
{
|
||
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
|
||
return con;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
PowerConnection* TopologyManager::ifConnection(const QString& entityId1,const QString& entityId2,ModelFunctionType funType)
|
||
{
|
||
QList<PowerConnection*> lst1;
|
||
QList<PowerConnection*> lst2;
|
||
|
||
QList<PowerTerminal*> lstTerminal1 = getTerminalsForEntity(entityId1,funType);
|
||
for(auto &terminal:lstTerminal1)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
|
||
if(con)
|
||
lst1.append(con);
|
||
}
|
||
|
||
QList<PowerTerminal*> lstTerminal2 = getTerminalsForEntity(entityId2,funType);
|
||
for(auto &terminal:lstTerminal2)
|
||
{
|
||
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
|
||
if(con)
|
||
lst2.append(con);
|
||
}
|
||
|
||
for(auto pCon1:lst1){
|
||
for(auto pCon2:lst2){
|
||
if(pCon1->id() == pCon2->id()){ //两个item的连接有重合，返回该连接
|
||
return pCon1;
|
||
}
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
QHash<QString,PowerConnection*> TopologyManager::getAllConnections(ModelFunctionType funType)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_connections;
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseConnections;
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
return m_editorConnections;
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
return m_blockConnections;
|
||
return QHash<QString,PowerConnection*>();
|
||
}
|
||
|
||
PowerEntity* TopologyManager::getEntity(const QString& id,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
auto it = m_entities.find(id);
|
||
return (it != m_entities.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
auto it = m_baseEntities.find(id);
|
||
return (it != m_baseEntities.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
auto it = m_editorEntities.find(id);
|
||
return (it != m_editorEntities.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
auto it = m_blockEntities.find(id);
|
||
return (it != m_blockEntities.end()) ? it.value() : nullptr;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
QList<PowerEntity*> TopologyManager::findEntitiesByName(const QString& name,ModelFunctionType funType) const
|
||
{
|
||
QList<PowerEntity*> results;
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
foreach (auto entity, m_entities) {
|
||
if (entity->name() == name) {
|
||
results.append(entity);
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
foreach (auto entity, m_baseEntities) {
|
||
if (entity->name() == name) {
|
||
results.append(entity);
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
foreach (auto entity, m_editorEntities) {
|
||
if (entity->name() == name) {
|
||
results.append(entity);
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
foreach (auto entity, m_blockEntities) {
|
||
if (entity->name() == name) {
|
||
results.append(entity);
|
||
}
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
PowerEntity* TopologyManager::createDiagram(const QString& id,const QString& name,ModelFunctionType funType)
|
||
{
|
||
PowerEntity* entity = nullptr;
|
||
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
if(!m_diagrams.contains(id))
|
||
{
|
||
entity = new ConfigurationDiagram(id,name);
|
||
m_diagrams.insert(entity->id(), entity);
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
if(!m_baseDiagrams.contains(id))
|
||
{
|
||
entity = new ConfigurationDiagram(id,name);
|
||
m_baseDiagrams.insert(entity->id(), entity);
|
||
}
|
||
}
|
||
|
||
return entity;
|
||
}
|
||
|
||
PowerEntity* TopologyManager::findDiagram(const QString& id,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_diagrams.value(id, nullptr); // 避免异常的安全查询
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseDiagrams.value(id, nullptr);
|
||
return nullptr;
|
||
}
|
||
|
||
bool TopologyManager::deleteDiagram(const QString& id,ModelFunctionType funType)
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
if (!m_diagrams.contains(id)) return false;
|
||
|
||
PowerEntity* entity = m_diagrams[id];
|
||
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteDiagram(child->id()); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_diagrams.remove(id);
|
||
delete entity; // 触发析构函数
|
||
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
if (!m_baseDiagrams.contains(id)) return false;
|
||
|
||
PowerEntity* entity = m_baseDiagrams[id];
|
||
|
||
// 步骤2：从父节点移除（防止悬空指针）
|
||
if (PowerEntity* parent = entity->parent()) {
|
||
parent->removeChild(entity);
|
||
}
|
||
|
||
// 步骤3：递归删除子实体
|
||
auto children = entity->children();
|
||
for (auto child : children) {
|
||
deleteDiagram(child->id(),funType); // 递归删除
|
||
}
|
||
|
||
// 步骤4：从哈希表移除并释放内存
|
||
m_baseDiagrams.remove(id);
|
||
delete entity; // 触发析构函数
|
||
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
PowerTerminal* TopologyManager::createTerminal(const QString& parentEntityId,
|
||
TerminalType type,
|
||
const QString& name,
|
||
const QPointF& relPos,
|
||
const QString& uuid,
|
||
ModelFunctionType funType) {
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
if (!m_entities.contains(parentEntityId)) return nullptr;
|
||
|
||
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
|
||
m_allTerminals[term->id()] = term;
|
||
m_terminalsByEntity[parentEntityId].append(term);
|
||
|
||
// 关联到父实体
|
||
if (PowerEntity* parent = getEntity(parentEntityId)) {
|
||
parent->addTerminal(term);
|
||
}
|
||
|
||
return term;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
if (!m_baseEntities.contains(parentEntityId)) return nullptr;
|
||
|
||
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
|
||
m_baseAllTerminals[term->id()] = term;
|
||
m_baseTerminalsByEntity[parentEntityId].append(term);
|
||
|
||
// 关联到父实体
|
||
if (PowerEntity* parent = getEntity(parentEntityId,funType)) {
|
||
parent->addTerminal(term);
|
||
}
|
||
|
||
return term;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
if (!m_editorEntities.contains(parentEntityId)) return nullptr;
|
||
|
||
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
|
||
m_editorAllTerminals[term->id()] = term;
|
||
m_editorTerminalsByEntity[parentEntityId].append(term);
|
||
|
||
// 关联到父实体
|
||
if (PowerEntity* parent = getEntity(parentEntityId,funType)) {
|
||
parent->addTerminal(term);
|
||
}
|
||
|
||
return term;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
if (!m_blockEntities.contains(parentEntityId)) return nullptr;
|
||
|
||
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
|
||
m_blockAllTerminals[term->id()] = term;
|
||
m_blockTerminalsByEntity[parentEntityId].append(term);
|
||
|
||
// 关联到父实体
|
||
if (PowerEntity* parent = getEntity(parentEntityId,funType)) {
|
||
parent->addTerminal(term);
|
||
}
|
||
|
||
return term;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
bool TopologyManager::deleteTerminal(const QString& terminalId,ModelFunctionType funType) {
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
if (!m_allTerminals.contains(terminalId)) return false;
|
||
|
||
PowerTerminal* term = m_allTerminals[terminalId];
|
||
QString parentId = term->parentEntityId();
|
||
|
||
// 从父实体移除
|
||
if (PowerEntity* parent = getEntity(parentId)) {
|
||
parent->removeTerminal(terminalId);
|
||
}
|
||
|
||
// 清理全局存储
|
||
m_terminalsByEntity[parentId].removeAll(term);
|
||
m_allTerminals.remove(terminalId);
|
||
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
if (!m_baseAllTerminals.contains(terminalId)) return false;
|
||
|
||
PowerTerminal* term = m_baseAllTerminals[terminalId];
|
||
QString parentId = term->parentEntityId();
|
||
|
||
// 从父实体移除
|
||
if (PowerEntity* parent = getEntity(parentId,funType)) {
|
||
parent->removeTerminal(terminalId);
|
||
}
|
||
|
||
// 清理全局存储
|
||
m_baseTerminalsByEntity[parentId].removeAll(term);
|
||
m_baseAllTerminals.remove(terminalId);
|
||
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
if (!m_editorAllTerminals.contains(terminalId)) return false;
|
||
|
||
PowerTerminal* term = m_editorAllTerminals[terminalId];
|
||
QString parentId = term->parentEntityId();
|
||
|
||
// 从父实体移除
|
||
if (PowerEntity* parent = getEntity(parentId,funType)) {
|
||
parent->removeTerminal(terminalId);
|
||
}
|
||
|
||
// 清理全局存储
|
||
m_editorTerminalsByEntity[parentId].removeAll(term);
|
||
m_editorAllTerminals.remove(terminalId);
|
||
|
||
return true;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
if (!m_blockAllTerminals.contains(terminalId)) return false;
|
||
|
||
PowerTerminal* term = m_blockAllTerminals[terminalId];
|
||
QString parentId = term->parentEntityId();
|
||
|
||
// 从父实体移除
|
||
if (PowerEntity* parent = getEntity(parentId,funType)) {
|
||
parent->removeTerminal(terminalId);
|
||
}
|
||
|
||
// 清理全局存储
|
||
m_blockTerminalsByEntity[parentId].removeAll(term);
|
||
m_blockAllTerminals.remove(terminalId);
|
||
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
PowerTerminal* TopologyManager::getTerminal(const QString& terminalId,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
auto it = m_allTerminals.find(terminalId);
|
||
return (it != m_allTerminals.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
auto it = m_baseAllTerminals.find(terminalId);
|
||
return (it != m_baseAllTerminals.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
auto it = m_editorAllTerminals.find(terminalId);
|
||
return (it != m_editorAllTerminals.end()) ? it.value() : nullptr;
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
auto it = m_blockAllTerminals.find(terminalId);
|
||
return (it != m_blockAllTerminals.end()) ? it.value() : nullptr;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
QList<PowerTerminal*> TopologyManager::getTerminalsForEntity(const QString& entityId,ModelFunctionType funType) const {
|
||
if(funType == ModelFunctionType::ProjectModel)
|
||
return m_terminalsByEntity.value(entityId);
|
||
else if(funType == ModelFunctionType::BaseModel)
|
||
return m_baseTerminalsByEntity.value(entityId);
|
||
else if(funType == ModelFunctionType::EditorModel)
|
||
return m_editorTerminalsByEntity.value(entityId);
|
||
else if(funType == ModelFunctionType::BlockEditorModel)
|
||
return m_blockTerminalsByEntity.value(entityId);
|
||
return QList<PowerTerminal*>();
|
||
}
|
||
|
||
PowerEntity* TopologyManager::getEntityByTerminal(const QString& terminalId,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
|
||
for(iter = m_terminalsByEntity.begin();iter != m_terminalsByEntity.end();++iter)
|
||
{
|
||
for(auto &terminal:iter.value())
|
||
{
|
||
if(terminal->id() == terminalId)
|
||
{
|
||
return m_entities[iter.key()];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
|
||
for(iter = m_baseTerminalsByEntity.begin();iter != m_baseTerminalsByEntity.end();++iter)
|
||
{
|
||
for(auto &terminal:iter.value())
|
||
{
|
||
if(terminal->id() == terminalId)
|
||
{
|
||
return m_baseEntities[iter.key()];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
|
||
for(iter = m_editorTerminalsByEntity.begin();iter != m_editorTerminalsByEntity.end();++iter)
|
||
{
|
||
for(auto &terminal:iter.value())
|
||
{
|
||
if(terminal->id() == terminalId)
|
||
{
|
||
return m_editorEntities[iter.key()];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
|
||
for(iter = m_blockTerminalsByEntity.begin();iter != m_blockTerminalsByEntity.end();++iter)
|
||
{
|
||
for(auto &terminal:iter.value())
|
||
{
|
||
if(terminal->id() == terminalId)
|
||
{
|
||
return m_blockEntities[iter.key()];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
PowerConnection* TopologyManager::getConnectionContainsTerminal(const QString& terminalId,ModelFunctionType funType) const
|
||
{
|
||
if(funType == ModelFunctionType::ProjectModel){
|
||
for(auto &con:m_connections)
|
||
{
|
||
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
|
||
{
|
||
return con;
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BaseModel){
|
||
for(auto &con:m_baseConnections)
|
||
{
|
||
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
|
||
{
|
||
return con;
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::EditorModel){
|
||
for(auto &con:m_editorConnections)
|
||
{
|
||
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
|
||
{
|
||
return con;
|
||
}
|
||
}
|
||
}
|
||
else if(funType == ModelFunctionType::BlockEditorModel){
|
||
for(auto &con:m_blockConnections)
|
||
{
|
||
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
|
||
{
|
||
return con;
|
||
}
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|