diff options
Diffstat (limited to 'src/corelib/kernel/qppsobject.cpp')
| -rw-r--r-- | src/corelib/kernel/qppsobject.cpp | 966 |
1 files changed, 0 insertions, 966 deletions
diff --git a/src/corelib/kernel/qppsobject.cpp b/src/corelib/kernel/qppsobject.cpp deleted file mode 100644 index f4001d3833..0000000000 --- a/src/corelib/kernel/qppsobject.cpp +++ /dev/null @@ -1,966 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2013 BlackBerry Limited. All rights reserved. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtCore module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - - -#include "qppsobject_p.h" - -#include "qppsobjectprivate_p.h" -#include "qppsattribute_p.h" -#include "qppsattributeprivate_p.h" -#include "qcore_unix_p.h" - -#include <QObject> -#include <QSocketNotifier> - -#include <unistd.h> -#include <fcntl.h> -#include <errno.h> -#include <string.h> -#include <confname.h> - -#include <sys/pps.h> - -QT_BEGIN_NAMESPACE - -/////////////////////////////////////////////////////////////////////////////// -static inline void safeAssign(bool *pointer, bool value) -{ - if (pointer) - *pointer = value; -} - -class QPpsMaxSize -{ -public: - QPpsMaxSize() - { - int fd = qt_safe_open("/pps/.all", O_RDONLY); - if (fd == -1) { - qWarning("qppsobject.cpp: qt_safe_open failed"); - value = -1; - } - - // This tells us the maximum transfer size across PPS - value = ::fpathconf(fd, _PC_REC_MAX_XFER_SIZE); - - qt_safe_close(fd); - } - - int value; -}; - -Q_GLOBAL_STATIC(QPpsMaxSize, ppsMaxSize) - - -/////////////////////////////////////////////////////////////////////////////// -// -// QPpsObjectPrivate -// -/////////////////////////////////////////////////////////////////////////////// - -QPpsObjectPrivate::QPpsObjectPrivate(const QString &path) - : notifier(0), - path(path), - error(EOK), - fd(-1), - readyReadEnabled(true) -{ -} - -QPpsAttributeMap QPpsObjectPrivate::decode(const QByteArray &rawData, bool *ok) -{ - QPpsAttributeMap attributeMap; - pps_decoder_t decoder; - - QByteArray mutableData(rawData); - pps_decoder_error_t error = pps_decoder_initialize(&decoder, mutableData.data()); - if (error == PPS_DECODER_OK) { - // no need to check ok in this case - attributeMap = decodeObject(&decoder, ok); - } else { - qWarning("QPpsObjectPrivate::decode: pps_decoder_initialize failed"); - *ok = false; - } - - pps_decoder_cleanup(&decoder); - return attributeMap; -} - -QVariantMap QPpsObjectPrivate::variantMapFromPpsAttributeMap(const QPpsAttributeMap &data) -{ - QVariantMap variantMap; - - for (QPpsAttributeMap::const_iterator it = data.constBegin(); it != data.constEnd(); ++it) { - QVariant variant = variantFromPpsAttribute(it.value()); - if (!variant.isValid()) - return QVariantMap(); - variantMap[it.key()] = variant; - } - - return variantMap; -} - -QPpsAttribute::Flags QPpsObjectPrivate::readFlags(pps_decoder_t *decoder) -{ - int rawFlags = pps_decoder_flags(decoder, 0); - - QPpsAttribute::Flags attributeFlags; - - if (rawFlags & PPS_INCOMPLETE) - attributeFlags |= QPpsAttribute::Incomplete; - if (rawFlags & PPS_DELETED) - attributeFlags |= QPpsAttribute::Deleted; - if (rawFlags & PPS_CREATED) - attributeFlags |= QPpsAttribute::Created; - if (rawFlags & PPS_TRUNCATED) - attributeFlags |= QPpsAttribute::Truncated; - if (rawFlags & PPS_PURGED) - attributeFlags |= QPpsAttribute::Purged; - - return attributeFlags; -} - -QPpsAttribute QPpsObjectPrivate::decodeString(pps_decoder_t *decoder) -{ - const char *value = 0; - pps_decoder_error_t error = pps_decoder_get_string(decoder, 0, &value); - - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeString: PPS_DECODER_GET_STRING failed"); - return QPpsAttribute(); - } - - QPpsAttribute::Flags flags = readFlags(decoder); - return QPpsAttributePrivate::createPpsAttribute(QString::fromUtf8(value), flags); -} - -QPpsAttribute QPpsObjectPrivate::decodeNumber(pps_decoder_t *decoder) -{ - // In order to support more number types, we have to do something stupid because the PPS - // library won't let us work any other way. Basically, we have to probe the encoded type in - // order to try to get exactly what we want. - int64_t llValue; - double dValue; - int iValue; - QPpsAttribute::Flags flags; - - if (pps_decoder_is_integer(decoder, 0)) { - pps_decoder_error_t error = pps_decoder_get_int(decoder, 0, &iValue); - switch (error) { - case PPS_DECODER_OK: - flags = readFlags(decoder); - return QPpsAttributePrivate::createPpsAttribute(iValue, flags); - case PPS_DECODER_CONVERSION_FAILED: - error = pps_decoder_get_int64(decoder, 0, &llValue); - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeNumber: failed to decode integer"); - return QPpsAttribute(); - } - flags = readFlags(decoder); - return QPpsAttributePrivate::createPpsAttribute(static_cast<long long>(llValue), flags); - default: - qWarning("QPpsObjectPrivate::decodeNumber: pps_decoder_get_int failed"); - return QPpsAttribute(); - } - } else { - pps_decoder_error_t error = pps_decoder_get_double(decoder, 0, &dValue); - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeNumber: pps_decoder_get_double failed"); - return QPpsAttribute(); - } - flags = readFlags(decoder); - return QPpsAttributePrivate::createPpsAttribute(dValue, flags); - } -} - -QPpsAttribute QPpsObjectPrivate::decodeBool(pps_decoder_t *decoder) -{ - bool value; - pps_decoder_error_t error = pps_decoder_get_bool(decoder, 0, &value); - - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeBool: pps_decoder_get_bool failed"); - return QPpsAttribute(); - } - - QPpsAttribute::Flags flags = readFlags(decoder); - return QPpsAttributePrivate::createPpsAttribute(value, flags); -} - -template<typename T> -QPpsAttribute QPpsObjectPrivate::decodeNestedData(T (*decodeFunction)(pps_decoder_t *, bool *), - pps_decoder_t *decoder) -{ - // We must read the flags before we push into the object, - // otherwise we'll get the flags for the first element in the object. - QPpsAttribute::Flags flags = readFlags(decoder); - - if (!decoderPush(decoder)) - return QPpsAttribute(); - - bool ok = false; - - T attributeContainer = decodeFunction(decoder, &ok); - - if (!ok) - return QPpsAttribute(); - - QPpsAttribute returnVal = QPpsAttributePrivate::createPpsAttribute(attributeContainer, flags); - - if (!decoderPop(decoder)) - return QPpsAttribute(); - - return returnVal; -} - -QPpsAttribute QPpsObjectPrivate::decodeData(pps_decoder_t *decoder) -{ - pps_node_type_t nodeType = pps_decoder_type(decoder, 0); - switch (nodeType) { - case PPS_TYPE_BOOL: - return decodeBool(decoder); - case PPS_TYPE_NUMBER: - return decodeNumber(decoder); - case PPS_TYPE_STRING: - return decodeString(decoder); - case PPS_TYPE_ARRAY: - return decodeNestedData(&QPpsObjectPrivate::decodeArray, decoder); - case PPS_TYPE_OBJECT: - return decodeNestedData(&QPpsObjectPrivate::decodeObject, decoder); - case PPS_TYPE_DELETED: { - // This should create an attribute with the flags set to PpsAttribute::Deleted. - // However, we need to create a valid QPpsAttribute while doing so. To do this, - // I'll create an empty map as a sentinel. Note that the readFlags() call with produce - // the correct set of flags. While I suspect that there will never be any other flags - // set in conjunction with this one, I'd rather not be surprised later. - QPpsAttributeMap emptyMap; - QPpsAttribute::Flags flags = readFlags(decoder); - QPpsAttribute returnVal = QPpsAttributePrivate::createPpsAttribute(emptyMap, flags); - return returnVal; - } - case PPS_TYPE_NULL: - case PPS_TYPE_NONE: - case PPS_TYPE_UNKNOWN: - default: - qWarning("QPpsObjectPrivate::decodeData: invalid pps_node_type"); - return QPpsAttribute(); - } -} - -QPpsAttributeList QPpsObjectPrivate::decodeArray(pps_decoder_t *decoder, bool *ok) -{ - QPpsAttributeList list; - - int length = pps_decoder_length(decoder); - for (int i = 0; i < length; ++i) { - // Force movement to a specific index. - pps_decoder_error_t error = pps_decoder_goto_index(decoder, i); - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeArray: pps_decoder_goto_index failed"); - *ok = false; - return QPpsAttributeList(); - } - - QPpsAttribute ppsAttribute = decodeData(decoder); - if (!ppsAttribute.isValid()) { - *ok = false; - return QPpsAttributeList(); - } - - list << ppsAttribute; - } - - *ok = true; - return list; -} - -QPpsAttributeMap QPpsObjectPrivate::decodeObject(pps_decoder_t *decoder, bool *ok) -{ - QPpsAttributeMap map; - - int length = pps_decoder_length(decoder); - for (int i = 0; i < length; ++i) { - // Force movement to a specific index. - pps_decoder_error_t error = pps_decoder_goto_index(decoder, i); - if (error != PPS_DECODER_OK) { - qWarning("QPpsObjectPrivate::decodeObject: pps_decoder_goto_index failed"); - *ok = false; - return QPpsAttributeMap(); - } - QString name = QString::fromUtf8(pps_decoder_name(decoder)); - QPpsAttribute ppsAttribute = decodeData(decoder); - if (!ppsAttribute.isValid()) { - *ok = false; - return QPpsAttributeMap(); - } - map[name] = ppsAttribute; - } - - *ok = true; - return map; -} - -QVariant QPpsObjectPrivate::variantFromPpsAttribute(const QPpsAttribute &attribute) -{ - switch (attribute.type()) { - case QPpsAttribute::Number: - switch (attribute.toVariant().type()) { - case QVariant::Int: - return attribute.toInt(); - case QVariant::LongLong: - return attribute.toLongLong(); - default: - return attribute.toDouble(); - } - break; - case QPpsAttribute::Bool: - return attribute.toBool(); - case QPpsAttribute::String: - return attribute.toString(); - case QPpsAttribute::Array: { - QVariantList variantList; - const auto attrs = attribute.toList(); - for (const QPpsAttribute &attr : attrs) { - QVariant variant = variantFromPpsAttribute(attr); - if (!variant.isValid()) - return QVariantList(); - variantList << variant; - } - return variantList; - } - case QPpsAttribute::Object: - return variantMapFromPpsAttributeMap(attribute.toMap()); - case QPpsAttribute::None: - default: - qWarning("QPpsObjectPrivate::variantFromPpsAttribute: invalid attribute parameter"); - return QVariant(); - } -} - -QByteArray QPpsObjectPrivate::encode(const QVariantMap &ppsData, bool *ok) -{ - pps_encoder_t encoder; - pps_encoder_initialize(&encoder, false); - - encodeObject(&encoder, ppsData, ok); - const char *rawData = 0; - if (*ok) { - // rawData points to a memory owned by encoder. - // The memory will be freed when pps_encoder_cleanup is called. - rawData = pps_encoder_buffer(&encoder); - if (!rawData) { - qWarning("QPpsObjectPrivate::encode: pps_encoder_buffer failed"); - *ok = false; - } - } - - pps_encoder_cleanup(&encoder); - return QByteArray(rawData); -} - -void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, const QVariant &data, - bool *ok) -{ - const char *errorFunction; - pps_encoder_error_t error = PPS_ENCODER_OK; - switch (data.type()) { - case QVariant::Bool: - error = pps_encoder_add_bool(encoder, name, data.toBool()); - errorFunction = "pps_encoder_add_bool"; - break; - // We want to support encoding uint even though libpps doesn't support it directly. - // We can't encode uint as an int since that will lose precision (e.g. 2^31+1 can't be - // encoded that way). However, we can convert uint to double without losing precision. - // QVariant.toDouble() conveniently takes care of the conversion for us. - case QVariant::UInt: - case QVariant::Double: - error = pps_encoder_add_double(encoder, name, data.toDouble()); - errorFunction = "pps_encoder_add_double"; - break; - case QVariant::Int: - error = pps_encoder_add_int(encoder, name, data.toInt()); - errorFunction = "pps_encoder_add_int"; - break; - case QVariant::LongLong: - error = pps_encoder_add_int64(encoder, name, data.toLongLong()); - errorFunction = "pps_encoder_add_int64"; - break; - case QVariant::String: - error = pps_encoder_add_string(encoder, name, data.toString().toUtf8().constData()); - errorFunction = "pps_encoder_add_string"; - break; - case QVariant::List: - error = pps_encoder_start_array(encoder, name); - errorFunction = "pps_encoder_start_array"; - if (error == PPS_ENCODER_OK) { - encodeArray(encoder, data.toList(), ok); - error = pps_encoder_end_array(encoder); - errorFunction = "pps_encoder_end_array"; - } - break; - case QVariant::Map: - error = pps_encoder_start_object(encoder, name); - errorFunction = "pps_encoder_start_object"; - if (error == PPS_ENCODER_OK) { - encodeObject(encoder, data.toMap(), ok); - error = pps_encoder_end_object(encoder); - errorFunction = "pps_encoder_end_object"; - } - break; - case QVariant::Invalid: - error = pps_encoder_add_null(encoder, name); - errorFunction = "pps_encoder_add_null"; - break; - default: - qWarning("QPpsObjectPrivate::encodeData: the type of the parameter data is invalid"); - *ok = false; - return; - } - - if (error != PPS_ENCODER_OK) { - qWarning("QPpsObjectPrivate::encodeData: %s failed", errorFunction); - *ok = false; - } else { - *ok = true; - } -} - -void QPpsObjectPrivate::encodeArray(pps_encoder_t *encoder, const QVariantList &data, bool *ok) -{ - for (QVariantList::const_iterator it = data.constBegin(); it != data.constEnd(); ++it) { - encodeData(encoder, 0, *it, ok); - if (!(*ok)) - return; - } - // if the passed data is empty, nothing went wrong and ok is set to true - *ok = true; -} - -void QPpsObjectPrivate::encodeObject(pps_encoder_t *encoder, const QVariantMap &data, bool *ok) -{ - for (QVariantMap::const_iterator it = data.constBegin(); it != data.constEnd(); ++it) { - encodeData(encoder, it.key().toUtf8().constData(), it.value(), ok); - if (!(*ok)) - return; - } - // if the passed data is empty, nothing went wrong and ok is set to true - *ok = true; -} - - - -/////////////////////////////////////////////////////////////////////////////// -// -// QPpsObjectPrivate -// -/////////////////////////////////////////////////////////////////////////////// - -QPpsObject::QPpsObject(const QString &path, QObject *parent) - : QObject(*new QPpsObjectPrivate(path), parent) -{ -} - -QPpsObject::~QPpsObject() -{ - // RAII - ensure file gets closed - if (isOpen()) - close(); -} - -int QPpsObject::error() const -{ - Q_D(const QPpsObject); - return d->error; -} - -QString QPpsObject::errorString() const -{ - Q_D(const QPpsObject); - return qt_error_string(d->error); -} - -bool QPpsObject::isReadyReadEnabled() const -{ - Q_D(const QPpsObject); - - // query state of read ready signal - return d->readyReadEnabled; -} - -void QPpsObject::setReadyReadEnabled(bool enable) -{ - Q_D(QPpsObject); - - // toggle whether socket notifier will emit a signal on read ready - d->readyReadEnabled = enable; - if (isOpen()) - d->notifier->setEnabled(enable); -} - -bool QPpsObject::isBlocking() const -{ - Q_D(const QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file not open - if (!isOpen()) { - d->error = EBADF; - return false; - } - - // query file status flags - int flags = fcntl(d->fd, F_GETFL); - if (flags == -1) { - d->error = errno; - return false; - } - // check if non-blocking flag is unset - return ((flags & O_NONBLOCK) != O_NONBLOCK); -} - -bool QPpsObject::setBlocking(bool enable) -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file not open - if (!isOpen()) { - d->error = EBADF; - return false; - } - - // query file status flags - int flags = fcntl(d->fd, F_GETFL); - if (flags == -1) { - d->error = errno; - return false; - } - - // configure non-blocking flag - if (enable) - flags &= ~O_NONBLOCK; - else - flags |= O_NONBLOCK; - - // update file status flags - flags = fcntl(d->fd, F_SETFL, flags); - if (flags == -1) { - d->error = errno; - return false; - } - - return true; -} - -bool QPpsObject::isOpen() const -{ - Q_D(const QPpsObject); - return (d->fd != -1); -} - -bool QPpsObject::open(QPpsObject::OpenModes mode) -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file already open - if (isOpen()) { - d->error = EBUSY; - return false; - } - - // convert pps flags to open flags - int oflags = 0; - if ((mode & QPpsObject::Publish) && (mode & QPpsObject::Subscribe)) - oflags |= O_RDWR; - else if (mode & QPpsObject::Publish) - oflags |= O_WRONLY; - else if (mode & QPpsObject::Subscribe) - oflags |= O_RDONLY; - - if (mode & QPpsObject::Create) - oflags |= O_CREAT | O_EXCL; - - if (mode & QPpsObject::DeleteContents) - oflags |= O_TRUNC; - - // open pps file - d->fd = qt_safe_open(d->path.toUtf8().data(), oflags, 0666); - if (d->fd == -1) { - d->error = errno; - return false; - } - // wire up socket notifier to know when reads are ready - d->notifier = new QSocketNotifier(d->fd, QSocketNotifier::Read, this); - d->notifier->setEnabled(d->readyReadEnabled); - QObject::connect(d->notifier, &QSocketNotifier::activated, this, &QPpsObject::readyRead); - return true; -} - -bool QPpsObject::close() -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file not open - if (!isOpen()) { - d->error = EBADF; - return false; - } - - // shutdown socket notifier - delete d->notifier; - d->notifier = 0; - - // close pps file - const int result = qt_safe_close(d->fd); - d->fd = -1; - - // check success of operation - if (result != 0) { - d->error = errno; - return false; - } - return true; -} - -QByteArray QPpsObject::read(bool *ok) -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file not open - if (!isOpen()) { - d->error = EBADF; - safeAssign(ok, false); - return QByteArray(); - } - - const int maxSize = ppsMaxSize->value; - if (maxSize == -1) { - qWarning("QPpsObject::read: maxSize is equal to -1"); - safeAssign(ok, false); - return QByteArray(); - } - - QByteArray byteArray; - byteArray.resize(maxSize); // resize doesn't initialize the data - const int result = qt_safe_read(d->fd, byteArray.data(), byteArray.size()); - - if (result == -1) { - d->error = errno; - qWarning() << "QPpsObject::read failed to read pps data, error " << errorString(); - safeAssign(ok, false); - return QByteArray(); // Specifically return a default-constructed QByteArray. - } - if (result == 0) { - // normalize the behavior of read() when no data is ready so a pps object - // put in non-blocking mode via opening w/o wait (read returns 0) looks - // the same as a pps object put in non-blocking mode by setting O_NONBLOCK - // (read returns EAGAIN) - d->error = EAGAIN; - safeAssign(ok, false); - return QByteArray(); // Specifically return a default-constructed QByteArray. - } - // resize byte array to amount actually read - byteArray.resize(result); - safeAssign(ok, true); - return byteArray; -} - -bool QPpsObject::write(const QByteArray &byteArray) -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // abort if file not open - if (!isOpen()) { - d->error = EBADF; - return false; - } - - // write entire byte array to pps file - const int result = qt_safe_write(d->fd, byteArray.data(), byteArray.size()); - if (result == -1) - d->error = errno; - - return (result == byteArray.size()); -} - -int QPpsObject::writeMessage(const QString &msg, const QVariantMap &dat) -{ - // Treat empty msg as an encoding error - if (msg.isEmpty()) - return -1; - - bool ok; - QByteArray byteArray = encodeMessage(msg, dat, &ok); - - if (!ok) - return -1; - - ok = write(byteArray); - if (!ok) - return error(); - - return EOK; -} - -int QPpsObject::writeMessage(const QString &msg, const QString &id, const QVariantMap &dat) -{ - // Treat empty msg or id as an encoding error - if (msg.isEmpty() || id.isEmpty()) - return -1; - - bool ok; - QByteArray byteArray = encodeMessage(msg, id, dat, &ok); - - if (!ok) - return -1; - - ok = write(byteArray); - if (!ok) - return error(); - - return EOK; -} - -bool QPpsObject::remove() -{ - Q_D(QPpsObject); - - // reset last error - d->error = EOK; - - // delete pps file - const int result = unlink(d->path.toUtf8().data()); - - // check success of operation - if (result != 0) { - d->error = errno; - return false; - } - return true; -} - -// static -QVariantMap QPpsObject::decode(const QByteArray &rawData, bool *ok) -{ - QPpsAttributeMap mapData = decodeWithFlags(rawData, 0, ok); - - // If *ok is false, then mapData is empty, so the resulting QVariantMap - // will also be empty, as desired. - return QPpsObjectPrivate::variantMapFromPpsAttributeMap(mapData); -} - -// static -QPpsAttributeMap QPpsObject::decodeWithFlags(const QByteArray &rawData, bool *ok) -{ - return QPpsObject::decodeWithFlags(rawData, 0, ok); -} - -// static -QPpsAttributeMap QPpsObject::decodeWithFlags(const QByteArray &rawData, - QPpsAttribute *objectAttribute, bool *ok) -{ - safeAssign(ok, true); - - bool success = false; - QPpsAttributeMap mapData = QPpsObjectPrivate::decode(rawData, &success); - if (!success) { - safeAssign(ok, false); - return QPpsAttributeMap(); - } - - // The object name is the key of the first element, and the flags of that attribute - // give the status for the object as a whole. - if (!mapData.isEmpty() && objectAttribute) { - QString extractedName = mapData.begin().key(); - QPpsAttribute topmostAttribute = mapData.begin().value(); - QPpsAttribute::Flags topmostFlags = topmostAttribute.flags(); - QPpsAttribute toplevelAttribute = - QPpsAttributePrivate::createPpsAttribute(extractedName, topmostFlags); - *objectAttribute = toplevelAttribute; - } - - return mapData; -} - - -// static -QByteArray QPpsObject::encode(const QVariantMap &ppsData, bool *ok) -{ - safeAssign(ok, true); - - bool success = false; - QByteArray byteArray = QPpsObjectPrivate::encode(ppsData, &success); - if (!success) { - safeAssign(ok, false); - return QByteArray(); - } - return byteArray; -} - -// static -QByteArray QPpsObject::encodeMessage(const QString &msg, const QVariantMap &dat, bool *ok) -{ - safeAssign(ok, true); - - // Treat empty msg as an encoding error - if (msg.isEmpty()) { - safeAssign(ok, false); - return QByteArray(); - } - - QVariantMap ppsData; - ppsData[QStringLiteral("msg")] = msg; - ppsData[QStringLiteral("dat")] = dat; - - return QPpsObject::encode(ppsData, ok); -} - -// static -QByteArray QPpsObject::encodeMessage(const QString &msg, const QString &id, const QVariantMap &dat, - bool *ok) -{ - safeAssign(ok, true); - - // Treat empty msg or id as an encoding error - if (msg.isEmpty() || id.isEmpty()) { - safeAssign(ok, false); - return QByteArray(); - } - - QVariantMap ppsData; - ppsData[QStringLiteral("msg")] = msg; - ppsData[QStringLiteral("id")] = id; - ppsData[QStringLiteral("dat")] = dat; - - return QPpsObject::encode(ppsData, ok); -} - -// static -int QPpsObject::sendMessage(const QString &path, const QString &message) -{ - QPpsObject pps(path); - - bool ok = pps.open(QPpsObject::Publish); - if (!ok) - return pps.error(); - - ok = pps.write(message.toLocal8Bit()); - if (!ok) - return pps.error(); - - return EOK; -} - -// static -int QPpsObject::sendMessage(const QString &path, const QVariantMap &message) -{ - QPpsObject pps(path); - - bool ok = pps.open(QPpsObject::Publish); - if (!ok) - return pps.error(); - - QByteArray payload = QPpsObject::encode(message, &ok); - if (!ok) - return -1; - - ok = pps.write(payload); - if (!ok) - return pps.error(); - - return EOK; -} - -// static -int QPpsObject::sendMessage(const QString &path, const QString &msg, const QVariantMap &dat) -{ - // Treat empty msg as an encoding error - if (msg.isEmpty()) - return -1; - - QPpsObject pps(path); - - bool ok = pps.open(QPpsObject::Publish); - if (!ok) - return pps.error(); - - QByteArray payload = QPpsObject::encodeMessage(msg, dat, &ok); - if (!ok) - return -1; - - ok = pps.write(payload); - if (!ok) - return pps.error(); - - return EOK; -} - -// static -int QPpsObject::sendMessage(const QString &path, const QByteArray &ppsData) -{ - QPpsObject pps(path); - - bool ok = pps.open(QPpsObject::Publish); - if (!ok) - return pps.error(); - - ok = pps.write(ppsData); - if (!ok) - return pps.error(); - - return EOK; -} - -QT_END_NAMESPACE |