jessequ
/
qamqp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor ValueType 

moved ValueType from the QAMQP namespace to QAMQP::MetaType namespace
to avoid clashes with very generic enum strings
This commit is contained in:
Matt Broadstone 2014-08-26 14:02:43 -04:00
parent 0ccb3035cd
commit bdd9bae8ea
11 changed files with 212 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/amqp_authenticator.cpp
View File

@ -40,7 +40,7 @@ void AMQPlainAuthenticator::setPassword(const QString &p)
void AMQPlainAuthenticator::write(QDataStream &out) void AMQPlainAuthenticator::write(QDataStream &out)
{ {
Frame::writeAmqpField(out, ShortString, type()); Frame::writeAmqpField(out, MetaType::ShortString, type());
Table response; Table response;
response["LOGIN"] = login_; response["LOGIN"] = login_;
response["PASSWORD"] = password_; response["PASSWORD"] = password_;

16
src/amqp_channel.cpp
View File

@ -114,7 +114,7 @@ void ChannelPrivate::flow(bool active)
{ {
QByteArray arguments; QByteArray arguments;
QDataStream stream(&arguments, QIODevice::WriteOnly); 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::Method frame(Frame::fcChannel, miFlow);
frame.setChannel(channelNumber); frame.setChannel(channelNumber);
@ -141,7 +141,7 @@ void ChannelPrivate::flowOk(const Frame::Method &frame)
Q_Q(Channel); Q_Q(Channel);
QByteArray data = frame.arguments(); QByteArray data = frame.arguments();
QDataStream stream(&data, QIODevice::ReadOnly); QDataStream stream(&data, QIODevice::ReadOnly);
bool active = Frame::readAmqpField(stream, Boolean).toBool(); bool active = Frame::readAmqpField(stream, MetaType::Boolean).toBool();
if (active) if (active)
Q_EMIT q->resumed(); Q_EMIT q->resumed();
else else
@ -154,15 +154,15 @@ void ChannelPrivate::close(int code, const QString &text, int classId, int metho
QDataStream stream(&arguments, QIODevice::WriteOnly); QDataStream stream(&arguments, QIODevice::WriteOnly);
if (!code) code = 200; if (!code) code = 200;
Frame::writeAmqpField(stream, ShortUint, code); Frame::writeAmqpField(stream, MetaType::ShortUint, code);
if (!text.isEmpty()) { if (!text.isEmpty()) {
Frame::writeAmqpField(stream, ShortString, text); Frame::writeAmqpField(stream, MetaType::ShortString, text);
} else { } else {
Frame::writeAmqpField(stream, ShortString, QLatin1String("OK")); Frame::writeAmqpField(stream, MetaType::ShortString, QLatin1String("OK"));
} }
Frame::writeAmqpField(stream, ShortUint, classId); Frame::writeAmqpField(stream, MetaType::ShortUint, classId);
Frame::writeAmqpField(stream, ShortUint, methodId); Frame::writeAmqpField(stream, MetaType::ShortUint, methodId);
Frame::Method frame(Frame::fcChannel, miClose); Frame::Method frame(Frame::fcChannel, miClose);
frame.setChannel(channelNumber); frame.setChannel(channelNumber);
@ -178,7 +178,7 @@ void ChannelPrivate::close(const Frame::Method &frame)
QDataStream stream(&data, QIODevice::ReadOnly); QDataStream stream(&data, QIODevice::ReadOnly);
qint16 code = 0, classId, methodId; qint16 code = 0, classId, methodId;
stream >> code; stream >> code;
QString text = Frame::readAmqpField(stream, ShortString).toString(); QString text = Frame::readAmqpField(stream, MetaType::ShortString).toString();
stream >> classId; stream >> classId;
stream >> methodId; stream >> methodId;

13
src/amqp_client.cpp
View File

@ -339,8 +339,9 @@ void ClientPrivate::start(const Frame::Method &frame)
Table table; Table table;
stream >> table; stream >> table;
QStringList mechanisms = Frame::readAmqpField(stream, LongString).toString().split(' '); QStringList mechanisms =
QString locales = Frame::readAmqpField(stream, LongString).toString(); Frame::readAmqpField(stream, MetaType::LongString).toString().split(' ');
QString locales = Frame::readAmqpField(stream, MetaType::LongString).toString();
qAmqpDebug(">> version_major: %d", version_major); qAmqpDebug(">> version_major: %d", version_major);
qAmqpDebug(">> version_minor: %d", version_minor); qAmqpDebug(">> version_minor: %d", version_minor);
@ -430,7 +431,7 @@ void ClientPrivate::close(const Frame::Method &frame)
QDataStream stream(&data, QIODevice::ReadOnly); QDataStream stream(&data, QIODevice::ReadOnly);
qint16 code = 0, classId, methodId; qint16 code = 0, classId, methodId;
stream >> code; stream >> code;
QString text = Frame::readAmqpField(stream, ShortString).toString(); QString text = Frame::readAmqpField(stream, MetaType::ShortString).toString();
stream >> classId; stream >> classId;
stream >> methodId; stream >> methodId;
@ -467,7 +468,7 @@ void ClientPrivate::startOk()
stream << clientProperties; stream << clientProperties;
authenticator->write(stream); authenticator->write(stream);
Frame::writeAmqpField(stream, ShortString, QLatin1String("en_US")); Frame::writeAmqpField(stream, MetaType::ShortString, QLatin1String("en_US"));
frame.setArguments(arguments); frame.setArguments(arguments);
sendFrame(frame); sendFrame(frame);
@ -498,7 +499,7 @@ void ClientPrivate::open()
QByteArray arguments; QByteArray arguments;
QDataStream stream(&arguments, QIODevice::WriteOnly); QDataStream stream(&arguments, QIODevice::WriteOnly);
Frame::writeAmqpField(stream, ShortString, virtualHost); Frame::writeAmqpField(stream, MetaType::ShortString, virtualHost);
stream << qint8(0); stream << qint8(0);
stream << qint8(0); stream << qint8(0);
@ -512,7 +513,7 @@ void ClientPrivate::close(int code, const QString &text, int classId, int method
QByteArray arguments; QByteArray arguments;
QDataStream stream(&arguments, QIODevice::WriteOnly); QDataStream stream(&arguments, QIODevice::WriteOnly);
stream << qint16(code); stream << qint16(code);
Frame::writeAmqpField(stream, ShortString, text); Frame::writeAmqpField(stream, MetaType::ShortString, text);
stream << qint16(classId); stream << qint16(classId);
stream << qint16(methodId); stream << qint16(methodId);

18
src/amqp_exchange.cpp
View File

@ -48,11 +48,11 @@ void ExchangePrivate::declare()
QDataStream stream(&args, QIODevice::WriteOnly); QDataStream stream(&args, QIODevice::WriteOnly);
stream << qint16(0); //reserved 1 stream << qint16(0); //reserved 1
Frame::writeAmqpField(stream, ShortString, name); Frame::writeAmqpField(stream, MetaType::ShortString, name);
Frame::writeAmqpField(stream, ShortString, type); Frame::writeAmqpField(stream, MetaType::ShortString, type);
stream << qint8(options); stream << qint8(options);
Frame::writeAmqpField(stream, Hash, arguments); Frame::writeAmqpField(stream, MetaType::Hash, arguments);
frame.setArguments(args); frame.setArguments(args);
sendFrame(frame); sendFrame(frame);
@ -131,9 +131,9 @@ void ExchangePrivate::basicReturn(const Frame::Method &frame)
quint16 replyCode; quint16 replyCode;
stream >> replyCode; stream >> replyCode;
QString replyText = Frame::readAmqpField(stream, ShortString).toString(); QString replyText = Frame::readAmqpField(stream, MetaType::ShortString).toString();
QString exchangeName = Frame::readAmqpField(stream, ShortString).toString(); QString exchangeName = Frame::readAmqpField(stream, MetaType::ShortString).toString();
QString routingKey = Frame::readAmqpField(stream, ShortString).toString(); QString routingKey = Frame::readAmqpField(stream, MetaType::ShortString).toString();
Error checkError = static_cast<Error>(replyCode); Error checkError = static_cast<Error>(replyCode);
if (checkError != QAMQP::NoError) { if (checkError != QAMQP::NoError) {
@ -208,7 +208,7 @@ void Exchange::remove(int options)
QDataStream stream(&arguments, QIODevice::WriteOnly); QDataStream stream(&arguments, QIODevice::WriteOnly);
stream << qint16(0); //reserved 1 stream << qint16(0); //reserved 1
Frame::writeAmqpField(stream, ShortString, d->name); Frame::writeAmqpField(stream, MetaType::ShortString, d->name);
stream << qint8(options); stream << qint8(options);
frame.setArguments(arguments); frame.setArguments(arguments);
@ -241,8 +241,8 @@ void Exchange::publish(const QByteArray &message, const QString &routingKey,
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
Frame::writeAmqpField(out, ShortString, routingKey); Frame::writeAmqpField(out, MetaType::ShortString, routingKey);
out << qint8(publishOptions); out << qint8(publishOptions);
frame.setArguments(arguments); frame.setArguments(arguments);

98
src/amqp_frame.cpp
View File

@ -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) { switch (type) {
case Boolean: case MetaType::Boolean:
{ {
quint8 octet = 0; quint8 octet = 0;
s >> octet; s >> octet;
return QVariant::fromValue<bool>(octet > 0); return QVariant::fromValue<bool>(octet > 0);
} }
case ShortShortUint: case MetaType::ShortShortUint:
{ {
quint8 octet = 0; quint8 octet = 0;
s >> octet; s >> octet;
return QVariant::fromValue<int>(octet); return QVariant::fromValue<int>(octet);
} }
case ShortUint: case MetaType::ShortUint:
{ {
quint16 tmp_value = 0; quint16 tmp_value = 0;
s >> tmp_value; s >> tmp_value;
return QVariant::fromValue<uint>(tmp_value); return QVariant::fromValue<uint>(tmp_value);
} }
case LongUint: case MetaType::LongUint:
{ {
quint32 tmp_value = 0; quint32 tmp_value = 0;
s >> tmp_value; s >> tmp_value;
return QVariant::fromValue<uint>(tmp_value); return QVariant::fromValue<uint>(tmp_value);
} }
case LongLongUint: case MetaType::LongLongUint:
{ {
qulonglong v = 0 ; qulonglong v = 0 ;
s >> v; s >> v;
return v; return v;
} }
case ShortString: case MetaType::ShortString:
{ {
qint8 size = 0; qint8 size = 0;
QByteArray buffer; QByteArray buffer;
@ -182,7 +182,7 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type)
s.readRawData(buffer.data(), buffer.size()); s.readRawData(buffer.data(), buffer.size());
return QString::fromLatin1(buffer.data(), size); return QString::fromLatin1(buffer.data(), size);
} }
case LongString: case MetaType::LongString:
{ {
quint32 size = 0; quint32 size = 0;
QByteArray buffer; QByteArray buffer;
@ -192,19 +192,19 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type)
s.readRawData(buffer.data(), buffer.size()); s.readRawData(buffer.data(), buffer.size());
return QString::fromUtf8(buffer.data(), buffer.size()); return QString::fromUtf8(buffer.data(), buffer.size());
} }
case Timestamp: case MetaType::Timestamp:
{ {
qulonglong tmp_value; qulonglong tmp_value;
s >> tmp_value; s >> tmp_value;
return QDateTime::fromMSecsSinceEpoch(tmp_value); return QDateTime::fromMSecsSinceEpoch(tmp_value);
} }
case Hash: case MetaType::Hash:
{ {
Table table; Table table;
s >> table; s >> table;
return table; return table;
} }
case Void: case MetaType::Void:
return QVariant(); return QVariant();
default: default:
qAmqpDebug() << Q_FUNC_INFO << "unsupported value type: " << type; qAmqpDebug() << Q_FUNC_INFO << "unsupported value type: " << type;
@ -213,25 +213,25 @@ QVariant Frame::readAmqpField(QDataStream &s, QAMQP::ValueType type)
return QVariant(); 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) { switch (type) {
case Boolean: case MetaType::Boolean:
s << (value.toBool() ? qint8(1) : qint8(0)); s << (value.toBool() ? qint8(1) : qint8(0));
break; break;
case ShortShortUint: case MetaType::ShortShortUint:
s << qint8(value.toUInt()); s << qint8(value.toUInt());
break; break;
case ShortUint: case MetaType::ShortUint:
s << quint16(value.toUInt()); s << quint16(value.toUInt());
break; break;
case LongUint: case MetaType::LongUint:
s << quint32(value.toUInt()); s << quint32(value.toUInt());
break; break;
case LongLongUint: case MetaType::LongLongUint:
s << qulonglong(value.toULongLong()); s << qulonglong(value.toULongLong());
break; break;
case ShortString: case MetaType::ShortString:
{ {
QString str = value.toString(); QString str = value.toString();
if (str.length() >= 256) { 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()); s.writeRawData(str.toUtf8().data(), str.length());
} }
break; break;
case LongString: case MetaType::LongString:
{ {
QString str = value.toString(); QString str = value.toString();
s << quint32(str.length()); s << quint32(str.length());
s.writeRawData(str.toLatin1().data(), str.length()); s.writeRawData(str.toLatin1().data(), str.length());
} }
break; break;
case Timestamp: case MetaType::Timestamp:
s << qulonglong(value.toDateTime().toMSecsSinceEpoch()); s << qulonglong(value.toDateTime().toMSecsSinceEpoch());
break; break;
case Hash: case MetaType::Hash:
{ {
Table table(value.toHash()); Table table(value.toHash());
s << table; s << table;
@ -301,46 +301,46 @@ qint32 Content::size() const
out << prop_; out << prop_;
if (prop_ & cpContentType) if (prop_ & cpContentType)
writeAmqpField(out, ShortString, properties_[cpContentType]); writeAmqpField(out, MetaType::ShortString, properties_[cpContentType]);
if (prop_ & cpContentEncoding) if (prop_ & cpContentEncoding)
writeAmqpField(out, ShortString, properties_[cpContentEncoding]); writeAmqpField(out, MetaType::ShortString, properties_[cpContentEncoding]);
if (prop_ & cpHeaders) if (prop_ & cpHeaders)
writeAmqpField(out, Hash, properties_[cpHeaders]); writeAmqpField(out, MetaType::Hash, properties_[cpHeaders]);
if (prop_ & cpDeliveryMode) if (prop_ & cpDeliveryMode)
writeAmqpField(out, ShortShortUint, properties_[cpDeliveryMode]); writeAmqpField(out, MetaType::ShortShortUint, properties_[cpDeliveryMode]);
if (prop_ & cpPriority) if (prop_ & cpPriority)
writeAmqpField(out, ShortShortUint, properties_[cpPriority]); writeAmqpField(out, MetaType::ShortShortUint, properties_[cpPriority]);
if (prop_ & cpCorrelationId) if (prop_ & cpCorrelationId)
writeAmqpField(out, ShortString, properties_[cpCorrelationId]); writeAmqpField(out, MetaType::ShortString, properties_[cpCorrelationId]);
if (prop_ & cpReplyTo) if (prop_ & cpReplyTo)
writeAmqpField(out, ShortString, properties_[cpReplyTo]); writeAmqpField(out, MetaType::ShortString, properties_[cpReplyTo]);
if (prop_ & cpExpiration) if (prop_ & cpExpiration)
writeAmqpField(out, ShortString, properties_[cpExpiration]); writeAmqpField(out, MetaType::ShortString, properties_[cpExpiration]);
if (prop_ & cpMessageId) if (prop_ & cpMessageId)
writeAmqpField(out, ShortString, properties_[cpMessageId]); writeAmqpField(out, MetaType::ShortString, properties_[cpMessageId]);
if (prop_ & cpTimestamp) if (prop_ & cpTimestamp)
writeAmqpField(out, Timestamp, properties_[cpTimestamp]); writeAmqpField(out, MetaType::Timestamp, properties_[cpTimestamp]);
if (prop_ & cpType) if (prop_ & cpType)
writeAmqpField(out, ShortString, properties_[cpType]); writeAmqpField(out, MetaType::ShortString, properties_[cpType]);
if (prop_ & cpUserId) if (prop_ & cpUserId)
writeAmqpField(out, ShortString, properties_[cpUserId]); writeAmqpField(out, MetaType::ShortString, properties_[cpUserId]);
if (prop_ & cpAppId) if (prop_ & cpAppId)
writeAmqpField(out, ShortString, properties_[cpAppId]); writeAmqpField(out, MetaType::ShortString, properties_[cpAppId]);
if (prop_ & cpClusterID) if (prop_ & cpClusterID)
writeAmqpField(out, ShortString, properties_[cpClusterID]); writeAmqpField(out, MetaType::ShortString, properties_[cpClusterID]);
return buffer_.size(); return buffer_.size();
} }
@ -378,46 +378,46 @@ void Content::readPayload(QDataStream &in)
qint16 flags_ = 0; qint16 flags_ = 0;
in >> flags_; in >> flags_;
if (flags_ & cpContentType) if (flags_ & cpContentType)
properties_[cpContentType] = readAmqpField(in, ShortString); properties_[cpContentType] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpContentEncoding) if (flags_ & cpContentEncoding)
properties_[cpContentEncoding] = readAmqpField(in, ShortString); properties_[cpContentEncoding] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpHeaders) if (flags_ & cpHeaders)
properties_[cpHeaders] = readAmqpField(in, Hash); properties_[cpHeaders] = readAmqpField(in, MetaType::Hash);
if (flags_ & cpDeliveryMode) if (flags_ & cpDeliveryMode)
properties_[cpDeliveryMode] = readAmqpField(in, ShortShortUint); properties_[cpDeliveryMode] = readAmqpField(in, MetaType::ShortShortUint);
if (flags_ & cpPriority) if (flags_ & cpPriority)
properties_[cpPriority] = readAmqpField(in, ShortShortUint); properties_[cpPriority] = readAmqpField(in, MetaType::ShortShortUint);
if (flags_ & cpCorrelationId) if (flags_ & cpCorrelationId)
properties_[cpCorrelationId] = readAmqpField(in, ShortString); properties_[cpCorrelationId] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpReplyTo) if (flags_ & cpReplyTo)
properties_[cpReplyTo] = readAmqpField(in, ShortString); properties_[cpReplyTo] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpExpiration) if (flags_ & cpExpiration)
properties_[cpExpiration] = readAmqpField(in, ShortString); properties_[cpExpiration] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpMessageId) if (flags_ & cpMessageId)
properties_[cpMessageId] = readAmqpField(in, ShortString); properties_[cpMessageId] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpTimestamp) if (flags_ & cpTimestamp)
properties_[cpTimestamp] = readAmqpField(in, Timestamp); properties_[cpTimestamp] = readAmqpField(in, MetaType::Timestamp);
if (flags_ & cpType) if (flags_ & cpType)
properties_[cpType] = readAmqpField(in, ShortString); properties_[cpType] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpUserId) if (flags_ & cpUserId)
properties_[cpUserId] = readAmqpField(in, ShortString); properties_[cpUserId] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpAppId) if (flags_ & cpAppId)
properties_[cpAppId] = readAmqpField(in, ShortString); properties_[cpAppId] = readAmqpField(in, MetaType::ShortString);
if (flags_ & cpClusterID) if (flags_ & cpClusterID)
properties_[cpClusterID] = readAmqpField(in, ShortString); properties_[cpClusterID] = readAmqpField(in, MetaType::ShortString);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////

4
src/amqp_frame_p.h
View File

@ -59,8 +59,8 @@ namespace Frame
fcTx = 90, fcTx = 90,
}; };
QVariant readAmqpField(QDataStream &s, QAMQP::ValueType type); QVariant readAmqpField(QDataStream &s, MetaType::ValueType type);
void writeAmqpField(QDataStream &s, QAMQP::ValueType type, const QVariant &value); void writeAmqpField(QDataStream &s, MetaType::ValueType type, const QVariant &value);
/* /*
* @brief Base class for any frames. * @brief Base class for any frames.

8
src/amqp_global.h
View File

@ -47,6 +47,8 @@
namespace QAMQP { namespace QAMQP {
namespace MetaType {
enum ValueType enum ValueType
{ {
Invalid = -1, Invalid = -1,
@ -75,6 +77,8 @@ enum ValueType
Void Void
}; };
} // namespace MetaType
enum Error enum Error
{ {
NoError = 0, NoError = 0,
@ -98,7 +102,7 @@ enum Error
InternalError = 541 InternalError = 541
}; };
struct decimal struct Decimal
{ {
qint8 scale; qint8 scale;
quint32 value; quint32 value;
@ -107,6 +111,6 @@ struct decimal
} // namespace QAMQP } // namespace QAMQP
Q_DECLARE_METATYPE(QAMQP::Error) Q_DECLARE_METATYPE(QAMQP::Error)
Q_DECLARE_METATYPE(QAMQP::decimal) Q_DECLARE_METATYPE(QAMQP::Decimal)
#endif // qamqp_global_h__ #endif // qamqp_global_h__

58
src/amqp_queue.cpp
View File

@ -127,7 +127,7 @@ void QueuePrivate::declareOk(const Frame::Method &frame)
QByteArray data = frame.arguments(); QByteArray data = frame.arguments();
QDataStream stream(&data, QIODevice::ReadOnly); QDataStream stream(&data, QIODevice::ReadOnly);
name = Frame::readAmqpField(stream, ShortString).toString(); name = Frame::readAmqpField(stream, MetaType::ShortString).toString();
qint32 messageCount = 0, consumerCount = 0; qint32 messageCount = 0, consumerCount = 0;
stream >> messageCount >> consumerCount; stream >> messageCount >> consumerCount;
qAmqpDebug("message count %d\nConsumer count: %d", 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); QDataStream in(&data, QIODevice::ReadOnly);
Message message; Message message;
message.d->deliveryTag = Frame::readAmqpField(in, LongLongUint).toLongLong(); message.d->deliveryTag = Frame::readAmqpField(in, MetaType::LongLongUint).toLongLong();
message.d->redelivered = Frame::readAmqpField(in, Boolean).toBool(); message.d->redelivered = Frame::readAmqpField(in, MetaType::Boolean).toBool();
message.d->exchangeName = Frame::readAmqpField(in, ShortString).toString(); message.d->exchangeName = Frame::readAmqpField(in, MetaType::ShortString).toString();
message.d->routingKey = Frame::readAmqpField(in, ShortString).toString(); message.d->routingKey = Frame::readAmqpField(in, MetaType::ShortString).toString();
currentMessage = message; currentMessage = message;
} }
@ -201,7 +201,7 @@ void QueuePrivate::consumeOk(const Frame::Method &frame)
qAmqpDebug() << "consume ok: " << name; qAmqpDebug() << "consume ok: " << name;
QByteArray data = frame.arguments(); QByteArray data = frame.arguments();
QDataStream stream(&data, QIODevice::ReadOnly); QDataStream stream(&data, QIODevice::ReadOnly);
consumerTag = Frame::readAmqpField(stream, ShortString).toString(); consumerTag = Frame::readAmqpField(stream, MetaType::ShortString).toString();
qAmqpDebug("consumer tag = %s", qPrintable(consumerTag)); qAmqpDebug("consumer tag = %s", qPrintable(consumerTag));
consuming = true; consuming = true;
Q_EMIT q->consuming(consumerTag); Q_EMIT q->consuming(consumerTag);
@ -212,17 +212,17 @@ void QueuePrivate::deliver(const Frame::Method &frame)
qAmqpDebug() << Q_FUNC_INFO; qAmqpDebug() << Q_FUNC_INFO;
QByteArray data = frame.arguments(); QByteArray data = frame.arguments();
QDataStream in(&data, QIODevice::ReadOnly); QDataStream in(&data, QIODevice::ReadOnly);
QString consumer = Frame::readAmqpField(in, ShortString).toString(); QString consumer = Frame::readAmqpField(in, MetaType::ShortString).toString();
if (consumerTag != consumer) { if (consumerTag != consumer) {
qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer; qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer;
return; return;
} }
Message message; Message message;
message.d->deliveryTag = Frame::readAmqpField(in, LongLongUint).toLongLong(); message.d->deliveryTag = Frame::readAmqpField(in, MetaType::LongLongUint).toLongLong();
message.d->redelivered = Frame::readAmqpField(in, Boolean).toBool(); message.d->redelivered = Frame::readAmqpField(in, MetaType::Boolean).toBool();
message.d->exchangeName = Frame::readAmqpField(in, ShortString).toString(); message.d->exchangeName = Frame::readAmqpField(in, MetaType::ShortString).toString();
message.d->routingKey = Frame::readAmqpField(in, ShortString).toString(); message.d->routingKey = Frame::readAmqpField(in, MetaType::ShortString).toString();
currentMessage = message; currentMessage = message;
} }
@ -235,9 +235,9 @@ void QueuePrivate::declare()
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, name); Frame::writeAmqpField(out, MetaType::ShortString, name);
out << qint8(options); out << qint8(options);
Frame::writeAmqpField(out, Hash, Table()); Frame::writeAmqpField(out, MetaType::Hash, Table());
frame.setArguments(arguments); frame.setArguments(arguments);
sendFrame(frame); sendFrame(frame);
@ -252,7 +252,7 @@ void QueuePrivate::cancelOk(const Frame::Method &frame)
qAmqpDebug() << Q_FUNC_INFO; qAmqpDebug() << Q_FUNC_INFO;
QByteArray data = frame.arguments(); QByteArray data = frame.arguments();
QDataStream in(&data, QIODevice::ReadOnly); QDataStream in(&data, QIODevice::ReadOnly);
QString consumer = Frame::readAmqpField(in, ShortString).toString(); QString consumer = Frame::readAmqpField(in, MetaType::ShortString).toString();
if (consumerTag != consumer) { if (consumerTag != consumer) {
qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer; qAmqpDebug() << Q_FUNC_INFO << "invalid consumer tag: " << consumer;
return; return;
@ -327,7 +327,7 @@ void Queue::remove(int options)
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
out << qint8(options); out << qint8(options);
frame.setArguments(arguments); frame.setArguments(arguments);
@ -347,7 +347,7 @@ void Queue::purge()
QByteArray arguments; QByteArray arguments;
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
out << qint8(0); // no-wait out << qint8(0); // no-wait
frame.setArguments(arguments); frame.setArguments(arguments);
@ -379,12 +379,12 @@ void Queue::bind(const QString &exchangeName, const QString &key)
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); // reserved 1 out << qint16(0); // reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
Frame::writeAmqpField(out, ShortString, exchangeName); Frame::writeAmqpField(out, MetaType::ShortString, exchangeName);
Frame::writeAmqpField(out, ShortString, key); Frame::writeAmqpField(out, MetaType::ShortString, key);
out << qint8(0); // no-wait out << qint8(0); // no-wait
Frame::writeAmqpField(out, Hash, Table()); Frame::writeAmqpField(out, MetaType::Hash, Table());
frame.setArguments(arguments); frame.setArguments(arguments);
d->sendFrame(frame); d->sendFrame(frame);
@ -414,10 +414,10 @@ void Queue::unbind(const QString &exchangeName, const QString &key)
QByteArray arguments; QByteArray arguments;
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
Frame::writeAmqpField(out, ShortString, exchangeName); Frame::writeAmqpField(out, MetaType::ShortString, exchangeName);
Frame::writeAmqpField(out, ShortString, key); Frame::writeAmqpField(out, MetaType::ShortString, key);
Frame::writeAmqpField(out, Hash, Table()); Frame::writeAmqpField(out, MetaType::Hash, Table());
frame.setArguments(arguments); frame.setArguments(arguments);
d->sendFrame(frame); d->sendFrame(frame);
@ -443,11 +443,11 @@ bool Queue::consume(int options)
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 out << qint16(0); //reserved 1
Frame::writeAmqpField(out, ShortString, d->name); Frame::writeAmqpField(out, MetaType::ShortString, d->name);
Frame::writeAmqpField(out, ShortString, d->consumerTag); Frame::writeAmqpField(out, MetaType::ShortString, d->consumerTag);
out << qint8(options); out << qint8(options);
Frame::writeAmqpField(out, Hash, Table()); Frame::writeAmqpField(out, MetaType::Hash, Table());
frame.setArguments(arguments); frame.setArguments(arguments);
d->sendFrame(frame); d->sendFrame(frame);
@ -487,7 +487,7 @@ void Queue::get(bool noAck)
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
out << qint16(0); //reserved 1 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 out << qint8(noAck ? 1 : 0); // no-ack
frame.setArguments(arguments); frame.setArguments(arguments);
@ -534,7 +534,7 @@ bool Queue::cancel(bool noWait)
QByteArray arguments; QByteArray arguments;
QDataStream out(&arguments, QIODevice::WriteOnly); QDataStream out(&arguments, QIODevice::WriteOnly);
Frame::writeAmqpField(out, ShortString, d->consumerTag); Frame::writeAmqpField(out, MetaType::ShortString, d->consumerTag);
out << (noWait ? qint8(0x01) : qint8(0x0)); out << (noWait ? qint8(0x01) : qint8(0x0));
frame.setArguments(arguments); frame.setArguments(arguments);

192
src/amqp_table.cpp
View File

@ -29,47 +29,47 @@ V - Void
x - Byte array x - Byte array
*/ */
ValueType valueTypeForOctet(qint8 octet) MetaType::ValueType valueTypeForOctet(qint8 octet)
{ {
switch (octet) { switch (octet) {
case 't': return Boolean; case 't': return MetaType::Boolean;
case 'b': return ShortShortInt; case 'b': return MetaType::ShortShortInt;
case 's': return ShortInt; case 's': return MetaType::ShortInt;
case 'I': return LongInt; case 'I': return MetaType::LongInt;
case 'l': return LongLongInt; case 'l': return MetaType::LongLongInt;
case 'f': return Float; case 'f': return MetaType::Float;
case 'd': return Double; case 'd': return MetaType::Double;
case 'D': return Decimal; case 'D': return MetaType::Decimal;
case 'S': return LongString; case 'S': return MetaType::LongString;
case 'A': return Array; case 'A': return MetaType::Array;
case 'T': return Timestamp; case 'T': return MetaType::Timestamp;
case 'F': return Hash; case 'F': return MetaType::Hash;
case 'V': return Void; case 'V': return MetaType::Void;
case 'x': return Bytes; case 'x': return MetaType::Bytes;
default: default:
qAmqpDebug() << Q_FUNC_INFO << "invalid octet received: " << char(octet); 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) { switch (type) {
case Boolean: return 't'; case MetaType::Boolean: return 't';
case ShortShortInt: return 'b'; case MetaType::ShortShortInt: return 'b';
case ShortInt: return 's'; case MetaType::ShortInt: return 's';
case LongInt: return 'I'; case MetaType::LongInt: return 'I';
case LongLongInt: return 'l'; case MetaType::LongLongInt: return 'l';
case Float: return 'f'; case MetaType::Float: return 'f';
case Double: return 'd'; case MetaType::Double: return 'd';
case Decimal: return 'D'; case MetaType::Decimal: return 'D';
case LongString: return 'S'; case MetaType::LongString: return 'S';
case Array: return 'A'; case MetaType::Array: return 'A';
case Timestamp: return 'T'; case MetaType::Timestamp: return 'T';
case Hash: return 'F'; case MetaType::Hash: return 'F';
case Void: return 'V'; case MetaType::Void: return 'V';
case Bytes: return 'x'; case MetaType::Bytes: return 'x';
default: default:
qAmqpDebug() << Q_FUNC_INFO << "invalid type received: " << char(type); 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) void Table::writeFieldValue(QDataStream &stream, const QVariant &value)
{ {
ValueType type; MetaType::ValueType type;
switch (value.userType()) { switch (value.userType()) {
case QMetaType::Bool: case QMetaType::Bool:
type = Boolean; type = MetaType::Boolean;
break; break;
case QMetaType::QByteArray: case QMetaType::QByteArray:
type = Bytes; type = MetaType::Bytes;
break; break;
case QMetaType::Int: case QMetaType::Int:
{ {
int i = qAbs(value.toInt()); int i = qAbs(value.toInt());
if (i <= qint8(SCHAR_MAX)) { if (i <= qint8(SCHAR_MAX)) {
type = ShortShortInt; type = MetaType::ShortShortInt;
} else if (i <= qint16(SHRT_MAX)) { } else if (i <= qint16(SHRT_MAX)) {
type = ShortInt; type = MetaType::ShortInt;
} else { } else {
type = LongInt; type = MetaType::LongInt;
} }
} }
break; break;
case QMetaType::UShort: case QMetaType::UShort:
type = ShortInt; type = MetaType::ShortInt;
break; break;
case QMetaType::UInt: case QMetaType::UInt:
{ {
int i = value.toInt(); int i = value.toInt();
if (i <= qint8(SCHAR_MAX)) { if (i <= qint8(SCHAR_MAX)) {
type = ShortShortInt; type = MetaType::ShortShortInt;
} else if (i <= qint16(SHRT_MAX)) { } else if (i <= qint16(SHRT_MAX)) {
type = ShortInt; type = MetaType::ShortInt;
} else { } else {
type = LongInt; type = MetaType::LongInt;
} }
} }
break; break;
case QMetaType::LongLong: case QMetaType::LongLong:
case QMetaType::ULongLong: case QMetaType::ULongLong:
type = LongLongInt; type = MetaType::LongLongInt;
break; break;
case QMetaType::QString: case QMetaType::QString:
type = LongString; type = MetaType::LongString;
break; break;
case QMetaType::QDateTime: case QMetaType::QDateTime:
type = Timestamp; type = MetaType::Timestamp;
break; break;
case QMetaType::Double: case QMetaType::Double:
type = value.toDouble() > FLT_MAX ? Double : Float; type = value.toDouble() > FLT_MAX ? MetaType::Double : MetaType::Float;
break; break;
case QMetaType::QVariantHash: case QMetaType::QVariantHash:
type = Hash; type = MetaType::Hash;
break; break;
case QMetaType::QVariantList: case QMetaType::QVariantList:
type = Array; type = MetaType::Array;
break; break;
case QMetaType::Void: case QMetaType::Void:
type = Void; type = MetaType::Void;
break; break;
default: default:
if (value.userType() == qMetaTypeId<QAMQP::decimal>()) { if (value.userType() == qMetaTypeId<QAMQP::Decimal>()) {
type = Decimal; type = MetaType::Decimal;
break; break;
} else if (!value.isValid()) { } else if (!value.isValid()) {
type = Void; type = MetaType::Void;
break; break;
} }
@ -154,33 +154,33 @@ void Table::writeFieldValue(QDataStream &stream, const QVariant &value)
writeFieldValue(stream, type, 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) { switch (type) {
case Boolean: case MetaType::Boolean:
case ShortShortUint: case MetaType::ShortShortUint:
case ShortUint: case MetaType::ShortUint:
case LongUint: case MetaType::LongUint:
case LongLongUint: case MetaType::LongLongUint:
case ShortString: case MetaType::ShortString:
case LongString: case MetaType::LongString:
case Timestamp: case MetaType::Timestamp:
case Hash: case MetaType::Hash:
return Frame::writeAmqpField(stream, type, value); return Frame::writeAmqpField(stream, type, value);
case ShortShortInt: case MetaType::ShortShortInt:
stream << qint8(value.toInt()); stream << qint8(value.toInt());
break; break;
case ShortInt: case MetaType::ShortInt:
stream << qint16(value.toInt()); stream << qint16(value.toInt());
break; break;
case LongInt: case MetaType::LongInt:
stream << qint32(value.toInt()); stream << qint32(value.toInt());
break; break;
case LongLongInt: case MetaType::LongLongInt:
stream << qlonglong(value.toLongLong()); stream << qlonglong(value.toLongLong());
break; break;
case Float: case MetaType::Float:
{ {
float g = value.toFloat(); float g = value.toFloat();
QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision(); QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision();
@ -189,7 +189,7 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant
stream.setFloatingPointPrecision(oldPrecision); stream.setFloatingPointPrecision(oldPrecision);
} }
break; break;
case Double: case MetaType::Double:
{ {
double g = value.toDouble(); double g = value.toDouble();
QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision(); QDataStream::FloatingPointPrecision oldPrecision = stream.floatingPointPrecision();
@ -198,14 +198,14 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant
stream.setFloatingPointPrecision(oldPrecision); stream.setFloatingPointPrecision(oldPrecision);
} }
break; break;
case Decimal: case MetaType::Decimal:
{ {
QAMQP::decimal v(value.value<QAMQP::decimal>()); QAMQP::Decimal v(value.value<QAMQP::Decimal>());
stream << v.scale; stream << v.scale;
stream << v.value; stream << v.value;
} }
break; break;
case Array: case MetaType::Array:
{ {
QByteArray buffer; QByteArray buffer;
QDataStream arrayStream(&buffer, QIODevice::WriteOnly); QDataStream arrayStream(&buffer, QIODevice::WriteOnly);
@ -220,14 +220,14 @@ void Table::writeFieldValue(QDataStream &stream, ValueType type, const QVariant
} }
} }
break; break;
case Bytes: case MetaType::Bytes:
{ {
QByteArray ba = value.toByteArray(); QByteArray ba = value.toByteArray();
stream << quint32(ba.length()); stream << quint32(ba.length());
stream.writeRawData(ba.data(), ba.length()); stream.writeRawData(ba.data(), ba.length());
} }
break; break;
case Void: case MetaType::Void:
stream << qint32(0); stream << qint32(0);
break; 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) { switch (type) {
case Boolean: case MetaType::Boolean:
case ShortShortUint: case MetaType::ShortShortUint:
case ShortUint: case MetaType::ShortUint:
case LongUint: case MetaType::LongUint:
case LongLongUint: case MetaType::LongLongUint:
case ShortString: case MetaType::ShortString:
case LongString: case MetaType::LongString:
case Timestamp: case MetaType::Timestamp:
case Hash: case MetaType::Hash:
return Frame::readAmqpField(stream, type); return Frame::readAmqpField(stream, type);
case ShortShortInt: case MetaType::ShortShortInt:
{ {
char octet; char octet;
stream.readRawData(&octet, sizeof(octet)); stream.readRawData(&octet, sizeof(octet));
return QVariant::fromValue<int>(octet); return QVariant::fromValue<int>(octet);
} }
case ShortInt: case MetaType::ShortInt:
{ {
qint16 tmp_value = 0; qint16 tmp_value = 0;
stream >> tmp_value; stream >> tmp_value;
return QVariant::fromValue<int>(tmp_value); return QVariant::fromValue<int>(tmp_value);
} }
case LongInt: case MetaType::LongInt:
{ {
qint32 tmp_value = 0; qint32 tmp_value = 0;
stream >> tmp_value; stream >> tmp_value;
return QVariant::fromValue<int>(tmp_value); return QVariant::fromValue<int>(tmp_value);
} }
case LongLongInt: case MetaType::LongLongInt:
{ {
qlonglong v = 0 ; qlonglong v = 0 ;
stream >> v; stream >> v;
return v; return v;
} }
case Float: case MetaType::Float:
{ {
float tmp_value; float tmp_value;
QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision(); QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision();
@ -283,7 +283,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type)
stream.setFloatingPointPrecision(precision); stream.setFloatingPointPrecision(precision);
return QVariant::fromValue<float>(tmp_value); return QVariant::fromValue<float>(tmp_value);
} }
case Double: case MetaType::Double:
{ {
double tmp_value; double tmp_value;
QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision(); QDataStream::FloatingPointPrecision precision = stream.floatingPointPrecision();
@ -292,14 +292,14 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type)
stream.setFloatingPointPrecision(precision); stream.setFloatingPointPrecision(precision);
return QVariant::fromValue<double>(tmp_value); return QVariant::fromValue<double>(tmp_value);
} }
case Decimal: case MetaType::Decimal:
{ {
QAMQP::decimal v; QAMQP::Decimal v;
stream >> v.scale; stream >> v.scale;
stream >> v.value; stream >> v.value;
return QVariant::fromValue<QAMQP::decimal>(v); return QVariant::fromValue<QAMQP::Decimal>(v);
} }
case Array: case MetaType::Array:
{ {
QByteArray data; QByteArray data;
quint32 size = 0; quint32 size = 0;
@ -317,7 +317,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type)
return result; return result;
} }
case Bytes: case MetaType::Bytes:
{ {
QByteArray bytes; QByteArray bytes;
quint32 length = 0; quint32 length = 0;
@ -326,7 +326,7 @@ QVariant Table::readFieldValue(QDataStream &stream, ValueType type)
stream.readRawData(bytes.data(), bytes.size()); stream.readRawData(bytes.data(), bytes.size());
return bytes; return bytes;
} }
case Void: case MetaType::Void:
break; break;
default: default:
qAmqpDebug() << Q_FUNC_INFO << "unhandled type: " << type; qAmqpDebug() << Q_FUNC_INFO << "unhandled type: " << type;
@ -342,7 +342,7 @@ QDataStream &operator<<(QDataStream &stream, const Table &table)
Table::ConstIterator it; Table::ConstIterator it;
Table::ConstIterator itEnd = table.constEnd(); Table::ConstIterator itEnd = table.constEnd();
for (it = table.constBegin(); it != itEnd; ++it) { 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()); Table::writeFieldValue(s, it.value());
} }
@ -362,7 +362,7 @@ QDataStream &operator>>(QDataStream &stream, Table &table)
QDataStream tableStream(&data, QIODevice::ReadOnly); QDataStream tableStream(&data, QIODevice::ReadOnly);
while (!tableStream.atEnd()) { while (!tableStream.atEnd()) {
qint8 octet = 0; qint8 octet = 0;
QString field = Frame::readAmqpField(tableStream, ShortString).toString(); QString field = Frame::readAmqpField(tableStream, MetaType::ShortString).toString();
tableStream >> octet; tableStream >> octet;
table[field] = Table::readFieldValue(tableStream, valueTypeForOctet(octet)); table[field] = Table::readFieldValue(tableStream, valueTypeForOctet(octet));
} }

4
src/amqp_table.h
View File

@ -16,8 +16,8 @@ public:
} }
static void writeFieldValue(QDataStream &stream, const QVariant &value); static void writeFieldValue(QDataStream &stream, const QVariant &value);
static void writeFieldValue(QDataStream &stream, ValueType type, const QVariant &value); static void writeFieldValue(QDataStream &stream, MetaType::ValueType type, const QVariant &value);
static QVariant readFieldValue(QDataStream &stream, ValueType type); static QVariant readFieldValue(QDataStream &stream, MetaType::ValueType type);
}; };
} // namespace QAMQP } // namespace QAMQP

6
tests/auto/qamqpqueue/tst_qamqpqueue.cpp
View File

@ -525,10 +525,10 @@ void tst_QAMQPQueue::tableFieldDataTypes()
Queue *queue = client->createQueue("test-table-field-data-types"); Queue *queue = client->createQueue("test-table-field-data-types");
declareQueueAndVerifyConsuming(queue); declareQueueAndVerifyConsuming(queue);
QAMQP::decimal decimal; QAMQP::Decimal decimal;
decimal.scale = 2; decimal.scale = 2;
decimal.value = 12345; decimal.value = 12345;
QVariant decimalVariant = QVariant::fromValue<QAMQP::decimal>(decimal); QVariant decimalVariant = QVariant::fromValue<QAMQP::Decimal>(decimal);
Table nestedTable; Table nestedTable;
nestedTable.insert("boolean", true); nestedTable.insert("boolean", true);
@ -593,7 +593,7 @@ void tst_QAMQPQueue::tableFieldDataTypes()
QVariantList compareArray = message.header("array").toList(); QVariantList compareArray = message.header("array").toList();
QCOMPARE(array, compareArray); QCOMPARE(array, compareArray);
QAMQP::decimal receivedDecimal = message.header("decimal-value").value<QAMQP::decimal>(); QAMQP::Decimal receivedDecimal = message.header("decimal-value").value<QAMQP::Decimal>();
QCOMPARE(receivedDecimal.scale, qint8(2)); QCOMPARE(receivedDecimal.scale, qint8(2));
QCOMPARE(receivedDecimal.value, quint32(12345)); QCOMPARE(receivedDecimal.value, quint32(12345));
} }