diff --git a/src/amqp_authenticator.cpp b/src/amqp_authenticator.cpp index e1b416b..9bbdb22 100644 --- a/src/amqp_authenticator.cpp +++ b/src/amqp_authenticator.cpp @@ -40,7 +40,7 @@ void AMQPlainAuthenticator::setPassword(const QString &p) void AMQPlainAuthenticator::write(QDataStream &out) { - Frame::writeAmqpField(out, ShortString, type()); + Frame::writeAmqpField(out, MetaType::ShortString, type()); Table response; response["LOGIN"] = login_; response["PASSWORD"] = password_; diff --git a/src/amqp_channel.cpp b/src/amqp_channel.cpp index 6d5dabb..7592f25 100644 --- a/src/amqp_channel.cpp +++ b/src/amqp_channel.cpp @@ -114,7 +114,7 @@ void ChannelPrivate::flow(bool active) { QByteArray arguments; QDataStream stream(&arguments, QIODevice::WriteOnly); - Frame::writeAmqpField(stream, ShortShortUint, (active ? 1 : 0)); + Frame::writeAmqpField(stream, MetaType::ShortShortUint, (active ? 1 : 0)); Frame::Method frame(Frame::fcChannel, miFlow); frame.setChannel(channelNumber); @@ -141,7 +141,7 @@ void ChannelPrivate::flowOk(const Frame::Method &frame) Q_Q(Channel); QByteArray data = frame.arguments(); QDataStream stream(&data, QIODevice::ReadOnly); - bool active = Frame::readAmqpField(stream, Boolean).toBool(); + bool active = Frame::readAmqpField(stream, MetaType::Boolean).toBool(); if (active) Q_EMIT q->resumed(); else @@ -154,15 +154,15 @@ void ChannelPrivate::close(int code, const QString &text, int classId, int metho QDataStream stream(&arguments, QIODevice::WriteOnly); if (!code) code = 200; - Frame::writeAmqpField(stream, ShortUint, code); + Frame::writeAmqpField(stream, MetaType::ShortUint, code); if (!text.isEmpty()) { - Frame::writeAmqpField(stream, ShortString, text); + Frame::writeAmqpField(stream, MetaType::ShortString, text); } else { - Frame::writeAmqpField(stream, ShortString, QLatin1String("OK")); + Frame::writeAmqpField(stream, MetaType::ShortString, QLatin1String("OK")); } - Frame::writeAmqpField(stream, ShortUint, classId); - Frame::writeAmqpField(stream, ShortUint, methodId); + Frame::writeAmqpField(stream, MetaType::ShortUint, classId); + Frame::writeAmqpField(stream, MetaType::ShortUint, methodId); Frame::Method frame(Frame::fcChannel, miClose); frame.setChannel(channelNumber); @@ -178,7 +178,7 @@ void ChannelPrivate::close(const Frame::Method &frame) QDataStream stream(&data, QIODevice::ReadOnly); qint16 code = 0, classId, methodId; stream >> code; - QString text = Frame::readAmqpField(stream, ShortString).toString(); + QString text = Frame::readAmqpField(stream, MetaType::ShortString).toString(); stream >> classId; stream >> methodId; diff --git a/src/amqp_client.cpp b/src/amqp_client.cpp index a7439c1..6b7cfbe 100644 --- a/src/amqp_client.cpp +++ b/src/amqp_client.cpp @@ -339,8 +339,9 @@ void ClientPrivate::start(const Frame::Method &frame) Table table; stream >> table; - QStringList mechanisms = Frame::readAmqpField(stream, LongString).toString().split(' '); - QString locales = Frame::readAmqpField(stream, LongString).toString(); + QStringList mechanisms = + Frame::readAmqpField(stream, MetaType::LongString).toString().split(' '); + QString locales = Frame::readAmqpField(stream, MetaType::LongString).toString(); qAmqpDebug(">> version_major: %d", version_major); qAmqpDebug(">> version_minor: %d", version_minor); @@ -430,7 +431,7 @@ void ClientPrivate::close(const Frame::Method &frame) QDataStream stream(&data, QIODevice::ReadOnly); qint16 code = 0, classId, methodId; stream >> code; - QString text = Frame::readAmqpField(stream, ShortString).toString(); + QString text = Frame::readAmqpField(stream, MetaType::ShortString).toString(); stream >> classId; stream >> methodId; @@ -467,7 +468,7 @@ void ClientPrivate::startOk() stream << clientProperties; authenticator->write(stream); - Frame::writeAmqpField(stream, ShortString, QLatin1String("en_US")); + Frame::writeAmqpField(stream, MetaType::ShortString, QLatin1String("en_US")); frame.setArguments(arguments); sendFrame(frame); @@ -498,7 +499,7 @@ void ClientPrivate::open() QByteArray arguments; QDataStream stream(&arguments, QIODevice::WriteOnly); - Frame::writeAmqpField(stream, ShortString, virtualHost); + Frame::writeAmqpField(stream, MetaType::ShortString, virtualHost); stream << qint8(0); stream << qint8(0); @@ -512,7 +513,7 @@ void ClientPrivate::close(int code, const QString &text, int classId, int method QByteArray arguments; QDataStream stream(&arguments, QIODevice::WriteOnly); stream << qint16(code); - Frame::writeAmqpField(stream, ShortString, text); + Frame::writeAmqpField(stream, MetaType::ShortString, text); stream << qint16(classId); stream << qint16(methodId); diff --git a/src/amqp_exchange.cpp b/src/amqp_exchange.cpp index 3f7a9d9..8b27437 100644 --- a/src/amqp_exchange.cpp +++ b/src/amqp_exchange.cpp @@ -48,11 +48,11 @@ void ExchangePrivate::declare() QDataStream stream(&args, QIODevice::WriteOnly); stream << qint16(0); //reserved 1 - Frame::writeAmqpField(stream, ShortString, name); - Frame::writeAmqpField(stream, ShortString, type); + Frame::writeAmqpField(stream, MetaType::ShortString, name); + Frame::writeAmqpField(stream, MetaType::ShortString, type); stream << qint8(options); - Frame::writeAmqpField(stream, Hash, arguments); + Frame::writeAmqpField(stream, MetaType::Hash, arguments); frame.setArguments(args); sendFrame(frame); @@ -131,9 +131,9 @@ void ExchangePrivate::basicReturn(const Frame::Method &frame) quint16 replyCode; stream >> replyCode; - QString replyText = Frame::readAmqpField(stream, ShortString).toString(); - QString exchangeName = Frame::readAmqpField(stream, ShortString).toString(); - QString routingKey = Frame::readAmqpField(stream, ShortString).toString(); + QString replyText = Frame::readAmqpField(stream, MetaType::ShortString).toString(); + QString exchangeName = Frame::readAmqpField(stream, MetaType::ShortString).toString(); + QString routingKey = Frame::readAmqpField(stream, MetaType::ShortString).toString(); Error checkError = static_cast(replyCode); if (checkError != QAMQP::NoError) { @@ -208,7 +208,7 @@ void Exchange::remove(int options) QDataStream stream(&arguments, QIODevice::WriteOnly); stream << qint16(0); //reserved 1 - Frame::writeAmqpField(stream, ShortString, d->name); + Frame::writeAmqpField(stream, MetaType::ShortString, d->name); stream << qint8(options); frame.setArguments(arguments); @@ -241,8 +241,8 @@ void Exchange::publish(const QByteArray &message, const QString &routingKey, QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); - Frame::writeAmqpField(out, ShortString, routingKey); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, routingKey); out << qint8(publishOptions); frame.setArguments(arguments); diff --git a/src/amqp_frame.cpp b/src/amqp_frame.cpp index a061875..9abf490 100644 --- a/src/amqp_frame.cpp +++ b/src/amqp_frame.cpp @@ -139,40 +139,40 @@ void Method::writePayload(QDataStream &stream) const ////////////////////////////////////////////////////////////////////////// -QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type) +QVariant Frame::readAmqpField(QDataStream &s, MetaType::ValueType type) { switch (type) { - case Boolean: + case MetaType::Boolean: { quint8 octet = 0; s >> octet; return QVariant::fromValue(octet > 0); } - case ShortShortUint: + case MetaType::ShortShortUint: { quint8 octet = 0; s >> octet; return QVariant::fromValue(octet); } - case ShortUint: + case MetaType::ShortUint: { quint16 tmp_value = 0; s >> tmp_value; return QVariant::fromValue(tmp_value); } - case LongUint: + case MetaType::LongUint: { quint32 tmp_value = 0; s >> tmp_value; return QVariant::fromValue(tmp_value); } - case LongLongUint: + case MetaType::LongLongUint: { qulonglong v = 0 ; s >> v; return v; } - case ShortString: + case MetaType::ShortString: { qint8 size = 0; QByteArray buffer; @@ -182,7 +182,7 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type) s.readRawData(buffer.data(), buffer.size()); return QString::fromLatin1(buffer.data(), size); } - case LongString: + case MetaType::LongString: { quint32 size = 0; QByteArray buffer; @@ -192,19 +192,19 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type) s.readRawData(buffer.data(), buffer.size()); return QString::fromUtf8(buffer.data(), buffer.size()); } - case Timestamp: + case MetaType::Timestamp: { qulonglong tmp_value; s >> tmp_value; return QDateTime::fromMSecsSinceEpoch(tmp_value); } - case Hash: + case MetaType::Hash: { Table table; s >> table; return table; } - case Void: + case MetaType::Void: return QVariant(); default: qAmqpDebug() << Q_FUNC_INFO << "unsupported value type: " << type; @@ -213,25 +213,25 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type) return QVariant(); } -void Frame::writeAmqpField(QDataStream &s, QAMQP::ValueType type, const QVariant &value) +void Frame::writeAmqpField(QDataStream &s, MetaType::ValueType type, const QVariant &value) { switch (type) { - case Boolean: + case MetaType::Boolean: s << (value.toBool() ? qint8(1) : qint8(0)); break; - case ShortShortUint: + case MetaType::ShortShortUint: s << qint8(value.toUInt()); break; - case ShortUint: + case MetaType::ShortUint: s << quint16(value.toUInt()); break; - case LongUint: + case MetaType::LongUint: s << quint32(value.toUInt()); break; - case LongLongUint: + case MetaType::LongLongUint: s << qulonglong(value.toULongLong()); break; - case ShortString: + case MetaType::ShortString: { QString str = value.toString(); if (str.length() >= 256) { @@ -242,17 +242,17 @@ void Frame::writeAmqpField(QDataStream &s, QAMQP::ValueType type, const QVariant s.writeRawData(str.toUtf8().data(), str.length()); } break; - case LongString: + case MetaType::LongString: { QString str = value.toString(); s << quint32(str.length()); s.writeRawData(str.toLatin1().data(), str.length()); } break; - case Timestamp: + case MetaType::Timestamp: s << qulonglong(value.toDateTime().toMSecsSinceEpoch()); break; - case Hash: + case MetaType::Hash: { Table table(value.toHash()); s << table; @@ -301,46 +301,46 @@ qint32 Content::size() const out << prop_; if (prop_ & cpContentType) - writeAmqpField(out, ShortString, properties_[cpContentType]); + writeAmqpField(out, MetaType::ShortString, properties_[cpContentType]); if (prop_ & cpContentEncoding) - writeAmqpField(out, ShortString, properties_[cpContentEncoding]); + writeAmqpField(out, MetaType::ShortString, properties_[cpContentEncoding]); if (prop_ & cpHeaders) - writeAmqpField(out, Hash, properties_[cpHeaders]); + writeAmqpField(out, MetaType::Hash, properties_[cpHeaders]); if (prop_ & cpDeliveryMode) - writeAmqpField(out, ShortShortUint, properties_[cpDeliveryMode]); + writeAmqpField(out, MetaType::ShortShortUint, properties_[cpDeliveryMode]); if (prop_ & cpPriority) - writeAmqpField(out, ShortShortUint, properties_[cpPriority]); + writeAmqpField(out, MetaType::ShortShortUint, properties_[cpPriority]); if (prop_ & cpCorrelationId) - writeAmqpField(out, ShortString, properties_[cpCorrelationId]); + writeAmqpField(out, MetaType::ShortString, properties_[cpCorrelationId]); if (prop_ & cpReplyTo) - writeAmqpField(out, ShortString, properties_[cpReplyTo]); + writeAmqpField(out, MetaType::ShortString, properties_[cpReplyTo]); if (prop_ & cpExpiration) - writeAmqpField(out, ShortString, properties_[cpExpiration]); + writeAmqpField(out, MetaType::ShortString, properties_[cpExpiration]); if (prop_ & cpMessageId) - writeAmqpField(out, ShortString, properties_[cpMessageId]); + writeAmqpField(out, MetaType::ShortString, properties_[cpMessageId]); if (prop_ & cpTimestamp) - writeAmqpField(out, Timestamp, properties_[cpTimestamp]); + writeAmqpField(out, MetaType::Timestamp, properties_[cpTimestamp]); if (prop_ & cpType) - writeAmqpField(out, ShortString, properties_[cpType]); + writeAmqpField(out, MetaType::ShortString, properties_[cpType]); if (prop_ & cpUserId) - writeAmqpField(out, ShortString, properties_[cpUserId]); + writeAmqpField(out, MetaType::ShortString, properties_[cpUserId]); if (prop_ & cpAppId) - writeAmqpField(out, ShortString, properties_[cpAppId]); + writeAmqpField(out, MetaType::ShortString, properties_[cpAppId]); if (prop_ & cpClusterID) - writeAmqpField(out, ShortString, properties_[cpClusterID]); + writeAmqpField(out, MetaType::ShortString, properties_[cpClusterID]); return buffer_.size(); } @@ -378,46 +378,46 @@ void Content::readPayload(QDataStream &in) qint16 flags_ = 0; in >> flags_; if (flags_ & cpContentType) - properties_[cpContentType] = readAmqpField(in, ShortString); + properties_[cpContentType] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpContentEncoding) - properties_[cpContentEncoding] = readAmqpField(in, ShortString); + properties_[cpContentEncoding] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpHeaders) - properties_[cpHeaders] = readAmqpField(in, Hash); + properties_[cpHeaders] = readAmqpField(in, MetaType::Hash); if (flags_ & cpDeliveryMode) - properties_[cpDeliveryMode] = readAmqpField(in, ShortShortUint); + properties_[cpDeliveryMode] = readAmqpField(in, MetaType::ShortShortUint); if (flags_ & cpPriority) - properties_[cpPriority] = readAmqpField(in, ShortShortUint); + properties_[cpPriority] = readAmqpField(in, MetaType::ShortShortUint); if (flags_ & cpCorrelationId) - properties_[cpCorrelationId] = readAmqpField(in, ShortString); + properties_[cpCorrelationId] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpReplyTo) - properties_[cpReplyTo] = readAmqpField(in, ShortString); + properties_[cpReplyTo] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpExpiration) - properties_[cpExpiration] = readAmqpField(in, ShortString); + properties_[cpExpiration] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpMessageId) - properties_[cpMessageId] = readAmqpField(in, ShortString); + properties_[cpMessageId] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpTimestamp) - properties_[cpTimestamp] = readAmqpField(in, Timestamp); + properties_[cpTimestamp] = readAmqpField(in, MetaType::Timestamp); if (flags_ & cpType) - properties_[cpType] = readAmqpField(in, ShortString); + properties_[cpType] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpUserId) - properties_[cpUserId] = readAmqpField(in, ShortString); + properties_[cpUserId] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpAppId) - properties_[cpAppId] = readAmqpField(in, ShortString); + properties_[cpAppId] = readAmqpField(in, MetaType::ShortString); if (flags_ & cpClusterID) - properties_[cpClusterID] = readAmqpField(in, ShortString); + properties_[cpClusterID] = readAmqpField(in, MetaType::ShortString); } ////////////////////////////////////////////////////////////////////////// diff --git a/src/amqp_frame_p.h b/src/amqp_frame_p.h index da5d8c3..c45c7ba 100644 --- a/src/amqp_frame_p.h +++ b/src/amqp_frame_p.h @@ -59,8 +59,8 @@ namespace Frame fcTx = 90, }; - QVariant readAmqpField(QDataStream &s, QAMQP::ValueType type); - void writeAmqpField(QDataStream &s, QAMQP::ValueType type, const QVariant &value); + QVariant readAmqpField(QDataStream &s, MetaType::ValueType type); + void writeAmqpField(QDataStream &s, MetaType::ValueType type, const QVariant &value); /* * @brief Base class for any frames. diff --git a/src/amqp_global.h b/src/amqp_global.h index 113ff8a..c95c777 100644 --- a/src/amqp_global.h +++ b/src/amqp_global.h @@ -47,6 +47,8 @@ namespace QAMQP { +namespace MetaType { + enum ValueType { Invalid = -1, @@ -75,6 +77,8 @@ enum ValueType Void }; +} // namespace MetaType + enum Error { NoError = 0, @@ -98,7 +102,7 @@ enum Error InternalError = 541 }; -struct decimal +struct Decimal { qint8 scale; quint32 value; @@ -107,6 +111,6 @@ struct decimal } // namespace QAMQP Q_DECLARE_METATYPE(QAMQP::Error) -Q_DECLARE_METATYPE(QAMQP::decimal) +Q_DECLARE_METATYPE(QAMQP::Decimal) #endif // qamqp_global_h__ diff --git a/src/amqp_queue.cpp b/src/amqp_queue.cpp index b44c7d3..43f82f7 100644 --- a/src/amqp_queue.cpp +++ b/src/amqp_queue.cpp @@ -127,7 +127,7 @@ void QueuePrivate::declareOk(const Frame::Method &frame) QByteArray data = frame.arguments(); QDataStream stream(&data, QIODevice::ReadOnly); - name = Frame::readAmqpField(stream, ShortString).toString(); + name = Frame::readAmqpField(stream, MetaType::ShortString).toString(); qint32 messageCount = 0, consumerCount = 0; stream >> messageCount >> consumerCount; qAmqpDebug("message count %d\nConsumer count: %d", messageCount, consumerCount); @@ -188,10 +188,10 @@ void QueuePrivate::getOk(const Frame::Method &frame) QDataStream in(&data, QIODevice::ReadOnly); Message message; - message.d->deliveryTag = Frame::readAmqpField(in, LongLongUint).toLongLong(); - message.d->redelivered = Frame::readAmqpField(in, Boolean).toBool(); - message.d->exchangeName = Frame::readAmqpField(in, ShortString).toString(); - message.d->routingKey = Frame::readAmqpField(in, ShortString).toString(); + message.d->deliveryTag = Frame::readAmqpField(in, MetaType::LongLongUint).toLongLong(); + message.d->redelivered = Frame::readAmqpField(in, MetaType::Boolean).toBool(); + message.d->exchangeName = Frame::readAmqpField(in, MetaType::ShortString).toString(); + message.d->routingKey = Frame::readAmqpField(in, MetaType::ShortString).toString(); currentMessage = message; } @@ -201,7 +201,7 @@ void QueuePrivate::consumeOk(const Frame::Method &frame) qAmqpDebug() << "consume ok: " << name; QByteArray data = frame.arguments(); QDataStream stream(&data, QIODevice::ReadOnly); - consumerTag = Frame::readAmqpField(stream, ShortString).toString(); + consumerTag = Frame::readAmqpField(stream, MetaType::ShortString).toString(); qAmqpDebug("consumer tag = %s", qPrintable(consumerTag)); consuming = true; Q_EMIT q->consuming(consumerTag); @@ -212,17 +212,17 @@ void QueuePrivate::deliver(const Frame::Method &frame) qAmqpDebug() << Q_FUNC_INFO; QByteArray data = frame.arguments(); QDataStream in(&data, QIODevice::ReadOnly); - QString consumer = Frame::readAmqpField(in, ShortString).toString(); + QString consumer = Frame::readAmqpField(in, MetaType::ShortString).toString(); if (consumerTag != consumer) { qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer; return; } Message message; - message.d->deliveryTag = Frame::readAmqpField(in, LongLongUint).toLongLong(); - message.d->redelivered = Frame::readAmqpField(in, Boolean).toBool(); - message.d->exchangeName = Frame::readAmqpField(in, ShortString).toString(); - message.d->routingKey = Frame::readAmqpField(in, ShortString).toString(); + message.d->deliveryTag = Frame::readAmqpField(in, MetaType::LongLongUint).toLongLong(); + message.d->redelivered = Frame::readAmqpField(in, MetaType::Boolean).toBool(); + message.d->exchangeName = Frame::readAmqpField(in, MetaType::ShortString).toString(); + message.d->routingKey = Frame::readAmqpField(in, MetaType::ShortString).toString(); currentMessage = message; } @@ -235,9 +235,9 @@ void QueuePrivate::declare() QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, name); + Frame::writeAmqpField(out, MetaType::ShortString, name); out << qint8(options); - Frame::writeAmqpField(out, Hash, Table()); + Frame::writeAmqpField(out, MetaType::Hash, Table()); frame.setArguments(arguments); sendFrame(frame); @@ -252,7 +252,7 @@ void QueuePrivate::cancelOk(const Frame::Method &frame) qAmqpDebug() << Q_FUNC_INFO; QByteArray data = frame.arguments(); QDataStream in(&data, QIODevice::ReadOnly); - QString consumer = Frame::readAmqpField(in, ShortString).toString(); + QString consumer = Frame::readAmqpField(in, MetaType::ShortString).toString(); if (consumerTag != consumer) { qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer; return; @@ -327,7 +327,7 @@ void Queue::remove(int options) QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); out << qint8(options); frame.setArguments(arguments); @@ -347,7 +347,7 @@ void Queue::purge() QByteArray arguments; QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); out << qint8(0); // no-wait frame.setArguments(arguments); @@ -379,12 +379,12 @@ void Queue::bind(const QString &exchangeName, const QString &key) QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); // reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); - Frame::writeAmqpField(out, ShortString, exchangeName); - Frame::writeAmqpField(out, ShortString, key); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, exchangeName); + Frame::writeAmqpField(out, MetaType::ShortString, key); out << qint8(0); // no-wait - Frame::writeAmqpField(out, Hash, Table()); + Frame::writeAmqpField(out, MetaType::Hash, Table()); frame.setArguments(arguments); d->sendFrame(frame); @@ -414,10 +414,10 @@ void Queue::unbind(const QString &exchangeName, const QString &key) QByteArray arguments; QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); - Frame::writeAmqpField(out, ShortString, exchangeName); - Frame::writeAmqpField(out, ShortString, key); - Frame::writeAmqpField(out, Hash, Table()); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, exchangeName); + Frame::writeAmqpField(out, MetaType::ShortString, key); + Frame::writeAmqpField(out, MetaType::Hash, Table()); frame.setArguments(arguments); d->sendFrame(frame); @@ -443,11 +443,11 @@ bool Queue::consume(int options) QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); - Frame::writeAmqpField(out, ShortString, d->consumerTag); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, d->consumerTag); out << qint8(options); - Frame::writeAmqpField(out, Hash, Table()); + Frame::writeAmqpField(out, MetaType::Hash, Table()); frame.setArguments(arguments); d->sendFrame(frame); @@ -487,7 +487,7 @@ void Queue::get(bool noAck) QDataStream out(&arguments, QIODevice::WriteOnly); out << qint16(0); //reserved 1 - Frame::writeAmqpField(out, ShortString, d->name); + Frame::writeAmqpField(out, MetaType::ShortString, d->name); out << qint8(noAck ? 1 : 0); // no-ack frame.setArguments(arguments); @@ -534,7 +534,7 @@ bool Queue::cancel(bool noWait) QByteArray arguments; QDataStream out(&arguments, QIODevice::WriteOnly); - Frame::writeAmqpField(out, ShortString, d->consumerTag); + Frame::writeAmqpField(out, MetaType::ShortString, d->consumerTag); out << (noWait ? qint8(0x01) : qint8(0x0)); frame.setArguments(arguments); diff --git a/src/amqp_table.cpp b/src/amqp_table.cpp index 7891b32..5d00a94 100644 --- a/src/amqp_table.cpp +++ b/src/amqp_table.cpp @@ -29,47 +29,47 @@ V - Void x - Byte array */ -ValueType valueTypeForOctet(qint8 octet) +MetaType::ValueType valueTypeForOctet(qint8 octet) { switch (octet) { - case 't': return Boolean; - case 'b': return ShortShortInt; - case 's': return ShortInt; - case 'I': return LongInt; - case 'l': return LongLongInt; - case 'f': return Float; - case 'd': return Double; - case 'D': return Decimal; - case 'S': return LongString; - case 'A': return Array; - case 'T': return Timestamp; - case 'F': return Hash; - case 'V': return Void; - case 'x': return Bytes; + case 't': return MetaType::Boolean; + case 'b': return MetaType::ShortShortInt; + case 's': return MetaType::ShortInt; + case 'I': return MetaType::LongInt; + case 'l': return MetaType::LongLongInt; + case 'f': return MetaType::Float; + case 'd': return MetaType::Double; + case 'D': return MetaType::Decimal; + case 'S': return MetaType::LongString; + case 'A': return MetaType::Array; + case 'T': return MetaType::Timestamp; + case 'F': return MetaType::Hash; + case 'V': return MetaType::Void; + case 'x': return MetaType::Bytes; default: qAmqpDebug() << Q_FUNC_INFO << "invalid octet received: " << char(octet); } - return Invalid; + return MetaType::Invalid; } -qint8 valueTypeToOctet(ValueType type) +qint8 valueTypeToOctet(MetaType::ValueType type) { switch (type) { - case Boolean: return 't'; - case ShortShortInt: return 'b'; - case ShortInt: return 's'; - case LongInt: return 'I'; - case LongLongInt: return 'l'; - case Float: return 'f'; - case Double: return 'd'; - case Decimal: return 'D'; - case LongString: return 'S'; - case Array: return 'A'; - case Timestamp: return 'T'; - case Hash: return 'F'; - case Void: return 'V'; - case Bytes: return 'x'; + case MetaType::Boolean: return 't'; + case MetaType::ShortShortInt: return 'b'; + case MetaType::ShortInt: return 's'; + case MetaType::LongInt: return 'I'; + case MetaType::LongLongInt: return 'l'; + case MetaType::Float: return 'f'; + case MetaType::Double: return 'd'; + case MetaType::Decimal: return 'D'; + case MetaType::LongString: return 'S'; + case MetaType::Array: return 'A'; + case MetaType::Timestamp: return 'T'; + case MetaType::Hash: return 'F'; + case MetaType::Void: return 'V'; + case MetaType::Bytes: return 'x'; default: qAmqpDebug() << Q_FUNC_INFO << "invalid type received: " << char(type); } @@ -79,69 +79,69 @@ qint8 valueTypeToOctet(ValueType type) void Table::writeFieldValue(QDataStream &stream, const QVariant &value) { - ValueType type; + MetaType::ValueType type; switch (value.userType()) { case QMetaType::Bool: - type = Boolean; + type = MetaType::Boolean; break; case QMetaType::QByteArray: - type = Bytes; + type = MetaType::Bytes; break; case QMetaType::Int: { int i = qAbs(value.toInt()); if (i <= qint8(SCHAR_MAX)) { - type = ShortShortInt; + type = MetaType::ShortShortInt; } else if (i <= qint16(SHRT_MAX)) { - type = ShortInt; + type = MetaType::ShortInt; } else { - type = LongInt; + type = MetaType::LongInt; } } break; case QMetaType::UShort: - type = ShortInt; + type = MetaType::ShortInt; break; case QMetaType::UInt: { int i = value.toInt(); if (i <= qint8(SCHAR_MAX)) { - type = ShortShortInt; + type = MetaType::ShortShortInt; } else if (i <= qint16(SHRT_MAX)) { - type = ShortInt; + type = MetaType::ShortInt; } else { - type = LongInt; + type = MetaType::LongInt; } } break; case QMetaType::LongLong: case QMetaType::ULongLong: - type = LongLongInt; + type = MetaType::LongLongInt; break; case QMetaType::QString: - type = LongString; + type = MetaType::LongString; break; case QMetaType::QDateTime: - type = Timestamp; + type = MetaType::Timestamp; break; case QMetaType::Double: - type = value.toDouble() > FLT_MAX ? Double : Float; + type = value.toDouble() > FLT_MAX ? MetaType::Double : MetaType::Float; break; case QMetaType::QVariantHash: - type = Hash; + type = MetaType::Hash; break; case QMetaType::QVariantList: - type = Array; + type = MetaType::Array; break; case QMetaType::Void: - type = Void; + type = MetaType::Void; break; default: - if (value.userType() == qMetaTypeId()) { - type = Decimal; + if (value.userType() == qMetaTypeId()) { + type = MetaType::Decimal; break; } else if (!value.isValid()) { - type = Void; + type = MetaType::Void; break; } @@ -154,33 +154,33 @@ void Table::writeFieldValue(QDataStream &stream, const QVariant &value) writeFieldValue(stream, type, value); } -void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant &value) +void Table::writeFieldValue(QDataStream &stream, MetaType::ValueType type, const QVariant &value) { switch (type) { - case Boolean: - case ShortShortUint: - case ShortUint: - case LongUint: - case LongLongUint: - case ShortString: - case LongString: - case Timestamp: - case Hash: + case MetaType::Boolean: + case MetaType::ShortShortUint: + case MetaType::ShortUint: + case MetaType::LongUint: + case MetaType::LongLongUint: + case MetaType::ShortString: + case MetaType::LongString: + case MetaType::Timestamp: + case MetaType::Hash: return Frame::writeAmqpField(stream, type, value); - case ShortShortInt: + case MetaType::ShortShortInt: stream << qint8(value.toInt()); break; - case ShortInt: + case MetaType::ShortInt: stream << qint16(value.toInt()); break; - case LongInt: + case MetaType::LongInt: stream << qint32(value.toInt()); break; - case LongLongInt: + case MetaType::LongLongInt: stream << qlonglong(value.toLongLong()); break; - case Float: + case MetaType::Float: { float g = value.toFloat(); QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision(); @@ -189,7 +189,7 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant stream.setFloatingPointPrecision(oldPrecision); } break; - case Double: + case MetaType::Double: { double g = value.toDouble(); QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision(); @@ -198,14 +198,14 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant stream.setFloatingPointPrecision(oldPrecision); } break; - case Decimal: + case MetaType::Decimal: { - QAMQP::decimal v(value.value()); + QAMQP::Decimal v(value.value()); stream << v.scale; stream << v.value; } break; - case Array: + case MetaType::Array: { QByteArray buffer; QDataStream arrayStream(&buffer, QIODevice::WriteOnly); @@ -220,14 +220,14 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant } } break; - case Bytes: + case MetaType::Bytes: { QByteArray ba = value.toByteArray(); stream << quint32(ba.length()); stream.writeRawData(ba.data(), ba.length()); } break; - case Void: + case MetaType::Void: stream << qint32(0); break; @@ -236,45 +236,45 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant } } -QVariant Table::readFieldValue(QDataStream &stream, ValueType type) +QVariant Table::readFieldValue(QDataStream &stream, MetaType::ValueType type) { switch (type) { - case Boolean: - case ShortShortUint: - case ShortUint: - case LongUint: - case LongLongUint: - case ShortString: - case LongString: - case Timestamp: - case Hash: + case MetaType::Boolean: + case MetaType::ShortShortUint: + case MetaType::ShortUint: + case MetaType::LongUint: + case MetaType::LongLongUint: + case MetaType::ShortString: + case MetaType::LongString: + case MetaType::Timestamp: + case MetaType::Hash: return Frame::readAmqpField(stream, type); - case ShortShortInt: + case MetaType::ShortShortInt: { char octet; stream.readRawData(&octet, sizeof(octet)); return QVariant::fromValue(octet); } - case ShortInt: + case MetaType::ShortInt: { qint16 tmp_value = 0; stream >> tmp_value; return QVariant::fromValue(tmp_value); } - case LongInt: + case MetaType::LongInt: { qint32 tmp_value = 0; stream >> tmp_value; return QVariant::fromValue(tmp_value); } - case LongLongInt: + case MetaType::LongLongInt: { qlonglong v = 0 ; stream >> v; return v; } - case Float: + case MetaType::Float: { float tmp_value; QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision(); @@ -283,7 +283,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type) stream.setFloatingPointPrecision(precision); return QVariant::fromValue(tmp_value); } - case Double: + case MetaType::Double: { double tmp_value; QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision(); @@ -292,14 +292,14 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type) stream.setFloatingPointPrecision(precision); return QVariant::fromValue(tmp_value); } - case Decimal: + case MetaType::Decimal: { - QAMQP::decimal v; + QAMQP::Decimal v; stream >> v.scale; stream >> v.value; - return QVariant::fromValue(v); + return QVariant::fromValue(v); } - case Array: + case MetaType::Array: { QByteArray data; quint32 size = 0; @@ -317,7 +317,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type) return result; } - case Bytes: + case MetaType::Bytes: { QByteArray bytes; quint32 length = 0; @@ -326,7 +326,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type) stream.readRawData(bytes.data(), bytes.size()); return bytes; } - case Void: + case MetaType::Void: break; default: qAmqpDebug() << Q_FUNC_INFO << "unhandled type: " << type; @@ -342,7 +342,7 @@ QDataStream &operator<<(QDataStream &stream, const Table &table) Table::ConstIterator it; Table::ConstIterator itEnd = table.constEnd(); for (it = table.constBegin(); it != itEnd; ++it) { - Table::writeFieldValue(s, ShortString, it.key()); + Table::writeFieldValue(s, MetaType::ShortString, it.key()); Table::writeFieldValue(s, it.value()); } @@ -362,7 +362,7 @@ QDataStream &operator>>(QDataStream &stream, Table &table) QDataStream tableStream(&data, QIODevice::ReadOnly); while (!tableStream.atEnd()) { qint8 octet = 0; - QString field = Frame::readAmqpField(tableStream, ShortString).toString(); + QString field = Frame::readAmqpField(tableStream, MetaType::ShortString).toString(); tableStream >> octet; table[field] = Table::readFieldValue(tableStream, valueTypeForOctet(octet)); } diff --git a/src/amqp_table.h b/src/amqp_table.h index f6f448a..e74bcd3 100644 --- a/src/amqp_table.h +++ b/src/amqp_table.h @@ -16,8 +16,8 @@ public: } static void writeFieldValue(QDataStream &stream, const QVariant &value); - static void writeFieldValue(QDataStream &stream, ValueType type, const QVariant &value); - static QVariant readFieldValue(QDataStream &stream, ValueType type); + static void writeFieldValue(QDataStream &stream, MetaType::ValueType type, const QVariant &value); + static QVariant readFieldValue(QDataStream &stream, MetaType::ValueType type); }; } // namespace QAMQP diff --git a/tests/auto/qamqpqueue/tst_qamqpqueue.cpp b/tests/auto/qamqpqueue/tst_qamqpqueue.cpp index 418dc2b..0f24fe5 100644 --- a/tests/auto/qamqpqueue/tst_qamqpqueue.cpp +++ b/tests/auto/qamqpqueue/tst_qamqpqueue.cpp @@ -525,10 +525,10 @@ void tst_QAMQPQueue::tableFieldDataTypes() Queue *queue = client->createQueue("test-table-field-data-types"); declareQueueAndVerifyConsuming(queue); - QAMQP::decimal decimal; + QAMQP::Decimal decimal; decimal.scale = 2; decimal.value = 12345; - QVariant decimalVariant = QVariant::fromValue(decimal); + QVariant decimalVariant = QVariant::fromValue(decimal); Table nestedTable; nestedTable.insert("boolean", true); @@ -593,7 +593,7 @@ void tst_QAMQPQueue::tableFieldDataTypes() QVariantList compareArray = message.header("array").toList(); QCOMPARE(array, compareArray); - QAMQP::decimal receivedDecimal = message.header("decimal-value").value(); + QAMQP::Decimal receivedDecimal = message.header("decimal-value").value(); QCOMPARE(receivedDecimal.scale, qint8(2)); QCOMPARE(receivedDecimal.value, quint32(12345)); }