679 lines
16 KiB
C++
679 lines
16 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-or-later
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* Copyright (C) 2013 - 2024, nymea GmbH
|
|
* Copyright (C) 2024 - 2025, chargebyte austria GmbH
|
|
*
|
|
* This file is part of libnymea-app.
|
|
*
|
|
* libnymea-app is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation, either version 3
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* libnymea-app is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with libnymea-app. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "zigbeenode.h"
|
|
|
|
#include <QMetaEnum>
|
|
#include <QRegularExpression>
|
|
|
|
ZigbeeNode::ZigbeeNode(const QUuid &networkUuid, const QString &ieeeAddress, QObject *parent) :
|
|
QObject(parent),
|
|
m_networkUuid(networkUuid),
|
|
m_ieeeAddress(ieeeAddress)
|
|
{
|
|
|
|
}
|
|
|
|
QUuid ZigbeeNode::networkUuid() const
|
|
{
|
|
return m_networkUuid;
|
|
}
|
|
|
|
QString ZigbeeNode::ieeeAddress() const
|
|
{
|
|
return m_ieeeAddress;
|
|
}
|
|
|
|
quint16 ZigbeeNode::networkAddress() const
|
|
{
|
|
return m_networkAddress;
|
|
}
|
|
|
|
void ZigbeeNode::setNetworkAddress(quint16 networkAddress)
|
|
{
|
|
if (m_networkAddress == networkAddress)
|
|
return;
|
|
|
|
m_networkAddress = networkAddress;
|
|
emit networkAddressChanged(m_networkAddress);
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeType ZigbeeNode::type() const
|
|
{
|
|
return m_type;
|
|
}
|
|
|
|
void ZigbeeNode::setType(ZigbeeNode::ZigbeeNodeType type)
|
|
{
|
|
if (m_type == type)
|
|
return;
|
|
|
|
m_type = type;
|
|
emit typeChanged(m_type);
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeState ZigbeeNode::state() const
|
|
{
|
|
return m_state;
|
|
}
|
|
|
|
void ZigbeeNode::setState(ZigbeeNode::ZigbeeNodeState state)
|
|
{
|
|
if (m_state == state)
|
|
return;
|
|
|
|
m_state = state;
|
|
emit stateChanged(m_state);
|
|
}
|
|
|
|
QString ZigbeeNode::manufacturer() const
|
|
{
|
|
return m_manufacturer;
|
|
}
|
|
|
|
void ZigbeeNode::setManufacturer(const QString &manufacturer)
|
|
{
|
|
if (m_manufacturer == manufacturer)
|
|
return;
|
|
|
|
m_manufacturer = manufacturer;
|
|
emit manufacturerChanged(m_manufacturer);
|
|
}
|
|
|
|
QString ZigbeeNode::model() const
|
|
{
|
|
return m_model;
|
|
}
|
|
|
|
void ZigbeeNode::setModel(const QString &model)
|
|
{
|
|
if (m_model == model)
|
|
return;
|
|
|
|
m_model = model;
|
|
emit modelChanged(m_model);
|
|
}
|
|
|
|
QString ZigbeeNode::version() const
|
|
{
|
|
return m_version;
|
|
}
|
|
|
|
void ZigbeeNode::setVersion(const QString &version)
|
|
{
|
|
if (m_version == version)
|
|
return;
|
|
|
|
m_version = version;
|
|
emit versionChanged(m_version);
|
|
}
|
|
|
|
bool ZigbeeNode::rxOnWhenIdle() const
|
|
{
|
|
return m_rxOnWhenIdle;
|
|
}
|
|
|
|
void ZigbeeNode::setRxOnWhenIdle(bool rxOnWhenIdle)
|
|
{
|
|
if (m_rxOnWhenIdle == rxOnWhenIdle)
|
|
return;
|
|
|
|
m_rxOnWhenIdle = rxOnWhenIdle;
|
|
emit rxOnWhenIdleChanged(m_rxOnWhenIdle);
|
|
}
|
|
|
|
bool ZigbeeNode::reachable() const
|
|
{
|
|
return m_reachable;
|
|
}
|
|
|
|
void ZigbeeNode::setReachable(bool reachable)
|
|
{
|
|
if (m_reachable == reachable)
|
|
return;
|
|
|
|
m_reachable = reachable;
|
|
emit reachableChanged(m_reachable);
|
|
}
|
|
|
|
uint ZigbeeNode::lqi() const
|
|
{
|
|
return m_lqi;
|
|
}
|
|
|
|
void ZigbeeNode::setLqi(uint lqi)
|
|
{
|
|
if (m_lqi == lqi)
|
|
return;
|
|
|
|
m_lqi = lqi;
|
|
emit lqiChanged(m_lqi);
|
|
|
|
}
|
|
|
|
QDateTime ZigbeeNode::lastSeen() const
|
|
{
|
|
return m_lastSeen;
|
|
}
|
|
|
|
void ZigbeeNode::setLastSeen(const QDateTime &lastSeen)
|
|
{
|
|
if (m_lastSeen == lastSeen)
|
|
return;
|
|
|
|
m_lastSeen = lastSeen;
|
|
emit lastSeenChanged(m_lastSeen);
|
|
}
|
|
|
|
QList<ZigbeeNodeNeighbor *> ZigbeeNode::neighbors() const
|
|
{
|
|
return m_neighbors;
|
|
}
|
|
|
|
void ZigbeeNode::addOrUpdateNeighbor(quint16 networkAddress, ZigbeeNodeRelationship relationship, quint8 lqi, quint8 depth, bool permitJoining)
|
|
{
|
|
foreach (ZigbeeNodeNeighbor *neighbor, m_neighbors) {
|
|
if (neighbor->networkAddress() == networkAddress) {
|
|
if (neighbor->relationship() != relationship) {
|
|
neighbor->setRelationship(relationship);
|
|
m_neighborsDirty = true;
|
|
}
|
|
if (neighbor->lqi() != lqi) {
|
|
neighbor->setLqi(lqi);
|
|
m_neighborsDirty = true;
|
|
}
|
|
if (neighbor->permitJoining() != permitJoining) {
|
|
neighbor->setPermitJoining(permitJoining);
|
|
m_neighborsDirty = true;
|
|
}
|
|
if (neighbor->depth() != depth) {
|
|
neighbor->setDepth(depth);
|
|
m_neighborsDirty = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
ZigbeeNodeNeighbor *neighbor = new ZigbeeNodeNeighbor(networkAddress, this);
|
|
neighbor->setRelationship(relationship);
|
|
neighbor->setLqi(lqi);
|
|
neighbor->setPermitJoining(permitJoining);
|
|
neighbor->setDepth(depth);
|
|
m_neighbors.append(neighbor);
|
|
m_neighborsDirty = true;
|
|
}
|
|
|
|
void ZigbeeNode::commitNeighbors(QList<quint16> toBeKept)
|
|
{
|
|
QMutableListIterator<ZigbeeNodeNeighbor*> iter(m_neighbors);
|
|
|
|
while (iter.hasNext()) {
|
|
ZigbeeNodeNeighbor *neighbor = iter.next();
|
|
if (!toBeKept.contains(neighbor->networkAddress())) {
|
|
iter.remove();
|
|
neighbor->deleteLater();
|
|
m_neighborsDirty = true;
|
|
}
|
|
}
|
|
if (m_neighborsDirty) {
|
|
emit neighborsChanged();
|
|
m_neighborsDirty = false;
|
|
}
|
|
}
|
|
|
|
QList<ZigbeeNodeRoute *> ZigbeeNode::routes() const
|
|
{
|
|
return m_routes;
|
|
}
|
|
|
|
void ZigbeeNode::addOrUpdateRoute(quint16 destinationAddress, quint16 nextHopAddress, ZigbeeNodeRouteStatus status, bool memoryConstrained, bool manyToOne)
|
|
{
|
|
foreach (ZigbeeNodeRoute *route, m_routes) {
|
|
if (route->destinationAddress() == destinationAddress) {
|
|
if (route->nextHopAddress() != nextHopAddress) {
|
|
route->setNextHopAddress(nextHopAddress);
|
|
m_routesDirty = true;
|
|
}
|
|
if (route->status() != status) {
|
|
route->setStatus(status);
|
|
m_routesDirty = true;
|
|
}
|
|
if (route->memoryConstrained() != memoryConstrained) {
|
|
route->setMemoryConstrained(memoryConstrained);
|
|
m_routesDirty = true;
|
|
}
|
|
if (route->manyToOne() != manyToOne) {
|
|
route->setManyToOne(manyToOne);
|
|
m_routesDirty = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
ZigbeeNodeRoute *route = new ZigbeeNodeRoute(destinationAddress, this);
|
|
route->setNextHopAddress(nextHopAddress);
|
|
route->setStatus(status);
|
|
route->setMemoryConstrained(memoryConstrained);
|
|
route->setManyToOne(manyToOne);
|
|
m_routes.append(route);
|
|
m_routesDirty = true;
|
|
}
|
|
|
|
void ZigbeeNode::commitRoutes(QList<quint16> toBeKept)
|
|
{
|
|
QMutableListIterator<ZigbeeNodeRoute*> iter(m_routes);
|
|
|
|
while (iter.hasNext()) {
|
|
ZigbeeNodeRoute *route = iter.next();
|
|
if (!toBeKept.contains(route->destinationAddress())) {
|
|
iter.remove();
|
|
route->deleteLater();
|
|
m_routesDirty = true;
|
|
}
|
|
}
|
|
if (m_routesDirty) {
|
|
emit routesChanged();
|
|
m_routesDirty = false;
|
|
}
|
|
}
|
|
|
|
QList<ZigbeeNodeBinding *> ZigbeeNode::bindings() const
|
|
{
|
|
return m_bindings;
|
|
}
|
|
|
|
void ZigbeeNode::addBinding(const QString &sourceAddress, quint8 sourceEndpointId, quint16 clusterId, quint16 groupAddress)
|
|
{
|
|
ZigbeeNodeBinding *newBinding = new ZigbeeNodeBinding(sourceAddress, sourceEndpointId, clusterId, groupAddress, this);
|
|
foreach (ZigbeeNodeBinding *binding, m_bindings) {
|
|
if (binding == newBinding) {
|
|
binding->setProperty("validated", true);
|
|
delete newBinding;
|
|
return;
|
|
}
|
|
}
|
|
newBinding->setProperty("validated", true);
|
|
m_bindings.append(newBinding);
|
|
m_bindingsDirty = true;
|
|
}
|
|
|
|
void ZigbeeNode::addBinding(const QString &sourceAddress, quint8 sourceEndpointId, quint16 clusterId, const QString &destinationAddress, quint8 destinationEndpointId)
|
|
{
|
|
ZigbeeNodeBinding *newBinding = new ZigbeeNodeBinding(sourceAddress, sourceEndpointId, clusterId, destinationAddress, destinationEndpointId, this);
|
|
foreach (ZigbeeNodeBinding *binding, m_bindings) {
|
|
if (binding == newBinding) {
|
|
binding->setProperty("validated", true);
|
|
delete newBinding;
|
|
return;
|
|
}
|
|
}
|
|
newBinding->setProperty("validated", true);
|
|
m_bindings.append(newBinding);
|
|
m_bindingsDirty = true;
|
|
}
|
|
|
|
void ZigbeeNode::commitBindings()
|
|
{
|
|
QMutableListIterator<ZigbeeNodeBinding*> it(m_bindings);
|
|
while (it.hasNext()) {
|
|
ZigbeeNodeBinding *binding = it.next();
|
|
if (!binding->property("validated").toBool()) {
|
|
it.remove();
|
|
m_bindingsDirty = true;
|
|
} else {
|
|
binding->setProperty("validated", false);
|
|
}
|
|
}
|
|
if (m_bindingsDirty) {
|
|
m_bindingsDirty = false;
|
|
emit bindingsChanged();
|
|
}
|
|
}
|
|
|
|
QList<ZigbeeNodeEndpoint *> ZigbeeNode::endpoints() const
|
|
{
|
|
return m_endpoints;
|
|
}
|
|
|
|
ZigbeeNodeEndpoint *ZigbeeNode::getEndpoint(quint8 endpointId) const
|
|
{
|
|
foreach (ZigbeeNodeEndpoint *endpoint, m_endpoints) {
|
|
if (endpoint->endpointId() == endpointId) {
|
|
return endpoint;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void ZigbeeNode::addEndpoint(ZigbeeNodeEndpoint *endpoint)
|
|
{
|
|
endpoint->setParent(this);
|
|
m_endpoints.append(endpoint);
|
|
emit endpointsChanged();
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeState ZigbeeNode::stringToNodeState(const QString &nodeState)
|
|
{
|
|
if (nodeState == "ZigbeeNodeStateUninitialized") {
|
|
return ZigbeeNodeStateUninitialized;
|
|
} else if (nodeState == "ZigbeeNodeStateInitializing") {
|
|
return ZigbeeNodeStateInitializing;
|
|
} else if (nodeState == "ZigbeeNodeStateInitialized") {
|
|
return ZigbeeNodeStateInitialized;
|
|
} else {
|
|
return ZigbeeNodeStateHandled;
|
|
}
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeType ZigbeeNode::stringToNodeType(const QString &nodeType)
|
|
{
|
|
if (nodeType == "ZigbeeNodeTypeCoordinator") {
|
|
return ZigbeeNodeTypeCoordinator;
|
|
} else if (nodeType == "ZigbeeNodeTypeRouter") {
|
|
return ZigbeeNodeTypeRouter;
|
|
} else {
|
|
return ZigbeeNodeTypeEndDevice;
|
|
}
|
|
}
|
|
|
|
ZigbeeNodeNeighbor::ZigbeeNodeNeighbor(quint16 networkAddress, QObject *parent):
|
|
QObject(parent),
|
|
m_networkAddress(networkAddress)
|
|
{
|
|
|
|
}
|
|
|
|
quint16 ZigbeeNodeNeighbor::networkAddress() const
|
|
{
|
|
return m_networkAddress;
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeRelationship ZigbeeNodeNeighbor::relationship() const
|
|
{
|
|
return m_relationship;
|
|
}
|
|
|
|
void ZigbeeNodeNeighbor::setRelationship(ZigbeeNode::ZigbeeNodeRelationship relationship)
|
|
{
|
|
if (m_relationship != relationship) {
|
|
m_relationship = relationship;
|
|
emit relationshipChanged();
|
|
}
|
|
}
|
|
|
|
quint8 ZigbeeNodeNeighbor::lqi() const
|
|
{
|
|
return m_lqi;
|
|
}
|
|
|
|
void ZigbeeNodeNeighbor::setLqi(quint8 lqi)
|
|
{
|
|
if (m_lqi != lqi) {
|
|
m_lqi = lqi;
|
|
emit lqiChanged();
|
|
}
|
|
}
|
|
|
|
quint8 ZigbeeNodeNeighbor::depth() const
|
|
{
|
|
return m_depth;
|
|
}
|
|
|
|
void ZigbeeNodeNeighbor::setDepth(quint8 depth)
|
|
{
|
|
if (m_depth != depth) {
|
|
m_depth = depth;
|
|
emit depthChanged();
|
|
}
|
|
}
|
|
|
|
bool ZigbeeNodeNeighbor::permitJoining() const
|
|
{
|
|
return m_permitJoining;
|
|
}
|
|
|
|
void ZigbeeNodeNeighbor::setPermitJoining(bool permitJoining)
|
|
{
|
|
if (m_permitJoining != permitJoining) {
|
|
m_permitJoining = permitJoining;
|
|
emit permitJoiningChanged();
|
|
}
|
|
}
|
|
|
|
ZigbeeNodeRoute::ZigbeeNodeRoute(quint16 destinationAddress, QObject *parent):
|
|
QObject(parent),
|
|
m_destinationAddress(destinationAddress)
|
|
{
|
|
|
|
}
|
|
|
|
quint16 ZigbeeNodeRoute::destinationAddress() const
|
|
{
|
|
return m_destinationAddress;
|
|
}
|
|
|
|
quint16 ZigbeeNodeRoute::nextHopAddress() const
|
|
{
|
|
return m_nextHopAddress;
|
|
}
|
|
|
|
void ZigbeeNodeRoute::setNextHopAddress(quint16 nextHopAddress)
|
|
{
|
|
if (m_nextHopAddress != nextHopAddress) {
|
|
m_nextHopAddress = nextHopAddress;
|
|
emit nextHopAddressChanged();
|
|
}
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeRouteStatus ZigbeeNodeRoute::status() const
|
|
{
|
|
return m_status;
|
|
}
|
|
|
|
void ZigbeeNodeRoute::setStatus(ZigbeeNode::ZigbeeNodeRouteStatus status)
|
|
{
|
|
if (m_status != status) {
|
|
m_status = status;
|
|
emit statusChanged();
|
|
}
|
|
}
|
|
|
|
bool ZigbeeNodeRoute::memoryConstrained() const
|
|
{
|
|
return m_memoryConstrained;
|
|
}
|
|
|
|
void ZigbeeNodeRoute::setMemoryConstrained(bool memoryConstrained)
|
|
{
|
|
if (m_memoryConstrained != memoryConstrained) {
|
|
m_memoryConstrained = memoryConstrained;
|
|
emit memoryConstrainedChanged();
|
|
}
|
|
}
|
|
|
|
bool ZigbeeNodeRoute::manyToOne() const
|
|
{
|
|
return m_manyToOne;
|
|
}
|
|
|
|
void ZigbeeNodeRoute::setManyToOne(bool manyToOne)
|
|
{
|
|
if (m_manyToOne != manyToOne) {
|
|
m_manyToOne = manyToOne;
|
|
emit manyToOneChanged();
|
|
}
|
|
}
|
|
|
|
ZigbeeNodeBinding::ZigbeeNodeBinding(const QString &sourceAddress, quint8 sourceEndointId, quint16 clusterId, quint16 groupAddress, QObject *parent):
|
|
QObject(parent),
|
|
m_sourceAddress(sourceAddress),
|
|
m_sourceEndpointId(sourceEndointId),
|
|
m_clusterId(clusterId),
|
|
m_type(ZigbeeNode::ZigbeeNodeBindingTypeGroup),
|
|
m_groupAddress(groupAddress)
|
|
{
|
|
|
|
}
|
|
|
|
ZigbeeNodeBinding::ZigbeeNodeBinding(const QString &sourceAddress, quint8 sourceEndointId, quint16 clusterId, const QString &destinationAddress, quint8 destinationEndpoint, QObject *parent):
|
|
QObject(parent),
|
|
m_sourceAddress(sourceAddress),
|
|
m_sourceEndpointId(sourceEndointId),
|
|
m_clusterId(clusterId),
|
|
m_type(ZigbeeNode::ZigbeeNodeBindingTypeDevice),
|
|
m_destinationAddress(destinationAddress),
|
|
m_destinationEndpointId(destinationEndpoint)
|
|
{
|
|
|
|
}
|
|
|
|
QString ZigbeeNodeBinding::sourceAddress() const
|
|
{
|
|
return m_sourceAddress;
|
|
}
|
|
|
|
quint8 ZigbeeNodeBinding::sourceEndpointId() const
|
|
{
|
|
return m_sourceEndpointId;
|
|
}
|
|
|
|
quint16 ZigbeeNodeBinding::clusterId() const
|
|
{
|
|
return m_clusterId;
|
|
}
|
|
|
|
ZigbeeNode::ZigbeeNodeBindingType ZigbeeNodeBinding::type() const
|
|
{
|
|
return m_type;
|
|
}
|
|
|
|
quint16 ZigbeeNodeBinding::groupAddress() const
|
|
{
|
|
return m_groupAddress;
|
|
}
|
|
|
|
QString ZigbeeNodeBinding::destinationAddress() const
|
|
{
|
|
return m_destinationAddress;
|
|
}
|
|
|
|
quint8 ZigbeeNodeBinding::destinationEndpointId() const
|
|
{
|
|
return m_destinationEndpointId;
|
|
}
|
|
|
|
ZigbeeCluster::ZigbeeCluster(quint16 clusterId, ZigbeeClusterDirection direction, QObject *parent):
|
|
QObject(parent),
|
|
m_clusterId(clusterId),
|
|
m_direction(direction)
|
|
{
|
|
|
|
}
|
|
|
|
quint16 ZigbeeCluster::clusterId() const
|
|
{
|
|
return m_clusterId;
|
|
}
|
|
|
|
ZigbeeCluster::ZigbeeClusterDirection ZigbeeCluster::direction() const
|
|
{
|
|
return m_direction;
|
|
}
|
|
|
|
ZigbeeNodeEndpoint::ZigbeeNodeEndpoint(quint8 endpointId, const QList<ZigbeeCluster*> &inputClusters, const QList<ZigbeeCluster*> &outputClusters, QObject *parent):
|
|
QObject(parent),
|
|
m_endpointId(endpointId),
|
|
m_inputClusters(inputClusters),
|
|
m_outputClusters(outputClusters)
|
|
{
|
|
foreach (ZigbeeCluster *cluster, inputClusters) {
|
|
cluster->setParent(this);
|
|
}
|
|
foreach (ZigbeeCluster *cluster, outputClusters) {
|
|
cluster->setParent(this);
|
|
}
|
|
}
|
|
|
|
quint8 ZigbeeNodeEndpoint::endpointId() const
|
|
{
|
|
return m_endpointId;
|
|
}
|
|
|
|
QList<ZigbeeCluster*> ZigbeeNodeEndpoint::inputClusters() const
|
|
{
|
|
return m_inputClusters;
|
|
}
|
|
|
|
ZigbeeCluster *ZigbeeNodeEndpoint::getInputCluster(quint16 clusterId) const
|
|
{
|
|
foreach (ZigbeeCluster *cluster, m_inputClusters) {
|
|
if (cluster->clusterId() == clusterId) {
|
|
return cluster;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void ZigbeeNodeEndpoint::addInputCluster(ZigbeeCluster *cluster)
|
|
{
|
|
cluster->setParent(this);
|
|
m_inputClusters.append(cluster);
|
|
emit inputClustersChanged();
|
|
}
|
|
|
|
QList<ZigbeeCluster*> ZigbeeNodeEndpoint::outputClusters() const
|
|
{
|
|
return m_outputClusters;
|
|
}
|
|
|
|
ZigbeeCluster *ZigbeeNodeEndpoint::getOutputCluster(quint16 clusterId) const
|
|
{
|
|
foreach (ZigbeeCluster *cluster, m_outputClusters) {
|
|
if (cluster->clusterId() == clusterId) {
|
|
return cluster;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void ZigbeeNodeEndpoint::addOutputCluster(ZigbeeCluster *cluster)
|
|
{
|
|
cluster->setParent(this);
|
|
m_outputClusters.append(cluster);
|
|
emit outputClustersChanged();
|
|
}
|
|
|
|
QString ZigbeeCluster::clusterName() const
|
|
{
|
|
QMetaEnum clusterEnum = QMetaEnum::fromType<ZigbeeClusterId>();
|
|
QString name = clusterEnum.valueToKey(m_clusterId);
|
|
name.remove("ZigbeeClusterId");
|
|
QRegularExpression re1 = QRegularExpression("([A-Z])([a-z]*)");
|
|
name.replace(re1, ";\\1\\2");
|
|
QStringList parts = name.split(";");
|
|
QString clusterName = parts.join(" ").trimmed();
|
|
if (clusterName.isEmpty()) {
|
|
clusterName = "0x" + QString::number(m_clusterId, 16);
|
|
}
|
|
return clusterName;
|
|
}
|