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)
{
Frame::writeAmqpField(out, ShortString, type());
Frame::writeAmqpField(out, MetaType::ShortString, type());
Table response;
response["LOGIN"] = login_;
response["PASSWORD"] = password_;

16
src/amqp_channel.cpp
View File

@ -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;

13
src/amqp_client.cpp
View File

@ -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);

18
src/amqp_exchange.cpp
View File

@ -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<Error>(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);

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) {
case Boolean:
case MetaType::Boolean:
{
quint8 octet = 0;
s >> octet;
return QVariant::fromValue<bool>(octet > 0);
}
case ShortShortUint:
case MetaType::ShortShortUint:
{
quint8 octet = 0;
s >> octet;
return QVariant::fromValue<int>(octet);
}
case ShortUint:
case MetaType::ShortUint:
{
quint16 tmp_value = 0;
s >> tmp_value;
return QVariant::fromValue<uint>(tmp_value);
}
case LongUint:
case MetaType::LongUint:
{
quint32 tmp_value = 0;
s >> tmp_value;
return QVariant::fromValue<uint>(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);
}
//////////////////////////////////////////////////////////////////////////

4
src/amqp_frame_p.h
View File

@ -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.

8
src/amqp_global.h
View File

@ -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__

58
src/amqp_queue.cpp
View File

@ -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);

192
src/amqp_table.cpp
View File

@ -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<QAMQP::decimal>()) {
type = Decimal;
if (value.userType() == qMetaTypeId<QAMQP::Decimal>()) {
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>());
QAMQP::Decimal v(value.value<QAMQP::Decimal>());
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<int>(octet);
}
case ShortInt:
case MetaType::ShortInt:
{
qint16 tmp_value = 0;
stream >> tmp_value;
return QVariant::fromValue<int>(tmp_value);
}
case LongInt:
case MetaType::LongInt:
{
qint32 tmp_value = 0;
stream >> tmp_value;
return QVariant::fromValue<int>(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<float>(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<double>(tmp_value);
}
case Decimal:
case MetaType::Decimal:
{
QAMQP::decimal v;
QAMQP::Decimal v;
stream >> v.scale;
stream >> v.value;
return QVariant::fromValue<QAMQP::decimal>(v);
return QVariant::fromValue<QAMQP::Decimal>(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));
}

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, 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

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");
declareQueueAndVerifyConsuming(queue);
QAMQP::decimal decimal;
QAMQP::Decimal decimal;
decimal.scale = 2;
decimal.value = 12345;
QVariant decimalVariant = QVariant::fromValue<QAMQP::decimal>(decimal);
QVariant decimalVariant = QVariant::fromValue<QAMQP::Decimal>(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>();
QAMQP::Decimal receivedDecimal = message.header("decimal-value").value<QAMQP::Decimal>();
QCOMPARE(receivedDecimal.scale, qint8(2));
QCOMPARE(receivedDecimal.value, quint32(12345));
}