#include <QHostAddress>
#ifdef HAVE_SSL
#include <QSslSocket>
+#include <utility>
#endif
#include "client.h"
/***********************************************************************************************/
-CoreAccountSettings::CoreAccountSettings(const QString &subgroup)
+CoreAccountSettings::CoreAccountSettings(QString subgroup)
: ClientSettings("CoreAccounts"),
- _subgroup(subgroup)
+ _subgroup(std::move(subgroup))
{
}
{
public:
// stores account-specific data in CoreAccounts/$ACCID/$SUBGROUP/$KEY)
- CoreAccountSettings(const QString &subgroup = "General");
+ CoreAccountSettings(QString subgroup = "General");
void notify(const QString &key, QObject *receiver, const char *slot) override;
#include <QAbstractItemView>
#include <QMimeData>
+#include <utility>
#include "buffermodel.h"
#include "buffersettings.h"
/*****************************************
* Fancy Buffer Items
*****************************************/
-BufferItem::BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
+BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
: PropertyMapItem(parent),
- _bufferInfo(bufferInfo),
+ _bufferInfo(std::move(bufferInfo)),
_activity(BufferInfo::NoActivity)
{
setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
Q_PROPERTY(int nickCount READ nickCount)
public :
- BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent = nullptr);
+ BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent = nullptr);
QStringList propertyOrder() const override;
#include <QCoreApplication>
#include <QDebug>
+#include <utility>
#include "quassel.h"
/*****************************************
* SimpleTreeItem
*****************************************/
-SimpleTreeItem::SimpleTreeItem(const QList<QVariant> &data, AbstractTreeItem *parent)
+SimpleTreeItem::SimpleTreeItem(QList<QVariant> data, AbstractTreeItem *parent)
: AbstractTreeItem(parent),
- _itemData(data)
+ _itemData(std::move(data))
{
}
Q_OBJECT
public:
- SimpleTreeItem(const QList<QVariant> &data, AbstractTreeItem *parent = nullptr);
+ SimpleTreeItem(QList<QVariant> data, AbstractTreeItem *parent = nullptr);
~SimpleTreeItem() override;
QVariant data(int column, int role) const override;
#include "common-export.h"
#include <QVariantMap>
+#include <utility>
#include "bufferinfo.h"
#include "syncableobject.h"
struct Alias {
QString name;
QString expansion;
- Alias(const QString &name_, const QString &expansion_) : name(name_), expansion(expansion_) {}
+ Alias(QString name_, QString expansion_) : name(std::move(name_)), expansion(std::move(expansion_)) {}
};
using AliasList = QList<Alias>;
#include <QDebug>
#include <QMetaMethod>
+#include <utility>
BasicHandler::BasicHandler(QObject *parent)
: QObject(parent),
}
-BasicHandler::BasicHandler(const QString &methodPrefix, QObject *parent)
+BasicHandler::BasicHandler(QString methodPrefix, QObject *parent)
: QObject(parent),
_defaultHandler(-1),
_initDone(false),
- _methodPrefix(methodPrefix)
+ _methodPrefix(std::move(methodPrefix))
{
}
public:
BasicHandler(QObject *parent = nullptr);
- BasicHandler(const QString &methodPrefix, QObject *parent = nullptr);
+ BasicHandler(QString methodPrefix, QObject *parent = nullptr);
QStringList providesHandlers();
#include <QDataStream>
#include <QDebug>
#include <QByteArray>
+#include <utility>
#include "bufferinfo.h"
_netid(networkid),
_type(type),
_groupId(gid),
- _bufferName(buf)
+ _bufferName(std::move(buf))
{
}
#include "buffersyncer.h"
+#include <utility>
+
BufferSyncer::BufferSyncer(QObject *parent)
: SyncableObject(parent)
{
BufferSyncer::BufferSyncer(
- const QHash<BufferId, MsgId> &lastSeenMsg,
- const QHash<BufferId, MsgId> &markerLines,
- const QHash<BufferId, Message::Types> &activities,
- const QHash<BufferId, int> &highlightCounts,
+ QHash<BufferId, MsgId> lastSeenMsg,
+ QHash<BufferId, MsgId> markerLines,
+ QHash<BufferId, Message::Types> activities,
+ QHash<BufferId, int> highlightCounts,
QObject *parent
) : SyncableObject(parent),
- _lastSeenMsg(lastSeenMsg),
- _markerLines(markerLines),
- _bufferActivities(activities),
- _highlightCounts(highlightCounts)
+ _lastSeenMsg(std::move(lastSeenMsg)),
+ _markerLines(std::move(markerLines)),
+ _bufferActivities(std::move(activities)),
+ _highlightCounts(std::move(highlightCounts))
{
}
public:
explicit BufferSyncer(QObject *parent);
- explicit BufferSyncer(const QHash<BufferId, MsgId> &lastSeenMsg, const QHash<BufferId, MsgId> &markerLines, const QHash<BufferId, Message::Types> &activities, const QHash<BufferId, int> &highlightCounts, QObject *parent);
+ explicit BufferSyncer(QHash<BufferId, MsgId> lastSeenMsg, QHash<BufferId, MsgId> markerLines, QHash<BufferId, Message::Types> activities, QHash<BufferId, int> highlightCounts, QObject *parent);
MsgId lastSeenMsg(BufferId buffer) const;
MsgId markerLine(BufferId buffer) const;
#include "ircevent.h"
#include <QUuid>
+#include <utility>
class COMMON_EXPORT CtcpEvent : public IrcEvent
{
Reply
};
- explicit CtcpEvent(EventManager::EventType type, Network *network, const QString &prefix, const QString &target,
- CtcpType ctcpType, const QString &ctcpCmd, const QString ¶m,
+ explicit CtcpEvent(EventManager::EventType type, Network *network, const QString &prefix, QString target,
+ CtcpType ctcpType, QString ctcpCmd, QString param,
const QDateTime ×tamp = QDateTime(), const QUuid &uuid = QUuid())
: IrcEvent(type, network, prefix),
_ctcpType(ctcpType),
- _ctcpCmd(ctcpCmd),
- _target(target),
- _param(param),
+ _ctcpCmd(std::move(ctcpCmd)),
+ _target(std::move(target)),
+ _param(std::move(param)),
_uuid(uuid)
{
setTimestamp(timestamp);
*/
HighlightRule(int id, QString contents, bool isRegEx, bool isCaseSensitive, bool isEnabled,
bool isInverse, QString sender, QString chanName)
- : _id(id), _contents(contents), _isRegEx(isRegEx), _isCaseSensitive(isCaseSensitive),
- _isEnabled(isEnabled), _isInverse(isInverse), _sender(sender), _chanName(chanName)
+ : _id(id), _contents(std::move(contents)), _isRegEx(isRegEx), _isCaseSensitive(isCaseSensitive),
+ _isEnabled(isEnabled), _isInverse(isInverse), _sender(std::move(sender)), _chanName(std::move(chanName))
{
_cacheInvalid = true;
// Cache expression matches on construction
#include <QString>
#include <QStringList>
#include <QRegExp>
+#include <utility>
#include "expressionmatch.h"
#include "message.h"
* @param scopeRule String representing a scope rule expression to match
* @param isEnabled True if enabled, otherwise false
*/
- IgnoreListItem(IgnoreType type, const QString &contents, bool isRegEx,
- StrictnessType strictness, ScopeType scope, const QString &scopeRule,
+ IgnoreListItem(IgnoreType type, QString contents, bool isRegEx,
+ StrictnessType strictness, ScopeType scope, QString scopeRule,
bool isEnabled)
- : _contents(contents), _isRegEx(isRegEx), _strictness(strictness),
- _scope(scope), _scopeRule(scopeRule), _isEnabled(isEnabled)
+ : _contents(std::move(contents)), _isRegEx(isRegEx), _strictness(strictness),
+ _scope(scope), _scopeRule(std::move(scopeRule)), _isEnabled(isEnabled)
{
// Allow passing empty "contents" as they can happen when editing an ignore rule
#pragma once
+#include <utility>
+
#include "common-export.h"
#include "networkevent.h"
class COMMON_EXPORT IrcEvent : public NetworkEvent
{
public:
- explicit IrcEvent(EventManager::EventType type, Network *network, const QString &prefix, const QStringList ¶ms = QStringList())
+ explicit IrcEvent(EventManager::EventType type, Network *network, QString prefix, QStringList params = QStringList())
: NetworkEvent(type, network),
- _prefix(prefix),
- _params(params)
+ _prefix(std::move(prefix)),
+ _params(std::move(params))
{}
inline QString prefix() const { return _prefix; }
class COMMON_EXPORT IrcEventNumeric : public IrcEvent
{
public:
- explicit IrcEventNumeric(uint number, Network *network, const QString &prefix, const QString &target, const QStringList ¶ms = QStringList())
+ explicit IrcEventNumeric(uint number, Network *network, const QString &prefix, QString target, const QStringList ¶ms = QStringList())
: IrcEvent(EventManager::IrcEventNumeric, network, prefix, params),
_number(number),
- _target(target)
+ _target(std::move(target))
{}
inline uint number() const { return _number; }
{
public:
explicit inline IrcEventRawMessage(EventManager::EventType type, Network *network,
- const QByteArray &rawMessage, const QString &prefix, const QString &target,
+ QByteArray rawMessage, const QString &prefix, const QString &target,
const QDateTime ×tamp = QDateTime())
: IrcEvent(type, network, prefix, QStringList() << target),
- _rawMessage(rawMessage)
+ _rawMessage(std::move(rawMessage))
{
setTimestamp(timestamp);
}
#pragma once
+#include <utility>
+
#include "common-export.h"
#include "syncableobject.h"
QString channelName;
quint32 userCount;
QString topic;
- ChannelDescription(const QString &channelName_, quint32 userCount_, const QString &topic_) : channelName(channelName_), userCount(userCount_), topic(topic_) {};
+ ChannelDescription(QString channelName_, quint32 userCount_, QString topic_) : channelName(std::move(channelName_)), userCount(userCount_), topic(std::move(topic_)) {};
};
public slots:
#include "signalproxy.h"
#include <QDataStream>
+#include <utility>
-Message::Message(const BufferInfo &bufferInfo, Type type, const QString &contents, const QString &sender,
- const QString &senderPrefixes, const QString &realName, const QString &avatarUrl, Flags flags)
+Message::Message(BufferInfo bufferInfo, Type type, QString contents, QString sender,
+ QString senderPrefixes, QString realName, QString avatarUrl, Flags flags)
: _timestamp(QDateTime::currentDateTime().toUTC()),
- _bufferInfo(bufferInfo),
- _contents(contents),
- _sender(sender),
- _senderPrefixes(senderPrefixes),
- _realName(realName),
- _avatarUrl(avatarUrl),
+ _bufferInfo(std::move(bufferInfo)),
+ _contents(std::move(contents)),
+ _sender(std::move(sender)),
+ _senderPrefixes(std::move(senderPrefixes)),
+ _realName(std::move(realName)),
+ _avatarUrl(std::move(avatarUrl)),
_type(type),
_flags(flags)
{
}
-Message::Message(const QDateTime &ts, const BufferInfo &bufferInfo, Type type, const QString &contents,
- const QString &sender, const QString &senderPrefixes, const QString &realName,
- const QString &avatarUrl, Flags flags)
- : _timestamp(ts),
- _bufferInfo(bufferInfo),
- _contents(contents),
- _sender(sender),
- _senderPrefixes(senderPrefixes),
- _realName(realName),
- _avatarUrl(avatarUrl),
+Message::Message(QDateTime ts, BufferInfo bufferInfo, Type type, QString contents,
+ QString sender, QString senderPrefixes, QString realName,
+ QString avatarUrl, Flags flags)
+ : _timestamp(std::move(ts)),
+ _bufferInfo(std::move(bufferInfo)),
+ _contents(std::move(contents)),
+ _sender(std::move(sender)),
+ _senderPrefixes(std::move(senderPrefixes)),
+ _realName(std::move(realName)),
+ _avatarUrl(std::move(avatarUrl)),
_type(type),
_flags(flags)
{
};
Q_DECLARE_FLAGS(Flags, Flag)
- Message(const BufferInfo &bufferInfo = BufferInfo(), Type type = Plain, const QString &contents = {},
- const QString &sender = {}, const QString &senderPrefixes = {}, const QString &realName = {},
- const QString &avatarUrl = {}, Flags flags = None);
- Message(const QDateTime &ts, const BufferInfo &buffer = BufferInfo(), Type type = Plain,
- const QString &contents = {}, const QString &sender = {}, const QString &senderPrefixes = {},
- const QString &realName = {}, const QString &avatarUrl = {}, Flags flags = None);
+ Message(BufferInfo bufferInfo = BufferInfo(), Type type = Plain, QString contents = {},
+ QString sender = {}, QString senderPrefixes = {}, QString realName = {},
+ QString avatarUrl = {}, Flags flags = None);
+ Message(QDateTime ts, BufferInfo buffer = BufferInfo(), Type type = Plain,
+ QString contents = {}, QString sender = {}, QString senderPrefixes = {},
+ QString realName = {}, QString avatarUrl = {}, Flags flags = None);
inline static Message ChangeOfDay(const QDateTime &day) { return Message(day, BufferInfo(), DayChange); }
inline const MsgId &msgId() const { return _msgId; }
#include "messageevent.h"
+#include <utility>
+
Event *MessageEvent::create(EventManager::EventType type, QVariantMap &map, Network *network)
{
if (type == EventManager::MessageEvent)
}
-MessageEvent::MessageEvent(Message::Type msgType, Network *net, const QString &msg, const QString &sender, const QString &target,
+MessageEvent::MessageEvent(Message::Type msgType, Network *net, QString msg, const QString &sender, QString target,
Message::Flags flags, const QDateTime ×tamp)
: NetworkEvent(EventManager::MessageEvent, net),
_msgType(msgType),
- _text(msg),
+ _text(std::move(msg)),
_sender(sender),
- _target(target),
+ _target(std::move(target)),
_msgFlags(flags)
{
IrcChannel *channel = network()->ircChannel(_target);
public:
explicit MessageEvent(Message::Type msgType,
Network *network,
- const QString &msg,
+ QString msg,
const QString &sender = QString(),
- const QString &target = QString(),
+ QString target = QString(),
Message::Flags msgFlags = Message::None,
const QDateTime ×tamp = QDateTime()
);
#include <QPointer>
#include <QMutex>
#include <QByteArray>
+#include <utility>
#include "types.h"
#include "util.h"
Server() : port(6667), useSsl(false), sslVerify(true), sslVersion(0), useProxy(false),
proxyType(QNetworkProxy::Socks5Proxy), proxyHost("localhost"), proxyPort(8080) {}
- Server(const QString &host, uint port, const QString &password, bool useSsl,
+ Server(QString host, uint port, QString password, bool useSsl,
bool sslVerify)
- : host(host), port(port), password(password), useSsl(useSsl), sslVerify(sslVerify),
+ : host(std::move(host)), port(port), password(std::move(password)), useSsl(useSsl), sslVerify(sslVerify),
sslVersion(0), useProxy(false), proxyType(QNetworkProxy::Socks5Proxy),
proxyHost("localhost"), proxyPort(8080) {}
#include <QStringList>
#include <QVariantList>
+#include <utility>
#include "event.h"
#include "network.h"
class COMMON_EXPORT NetworkDataEvent : public NetworkEvent
{
public:
- explicit NetworkDataEvent(EventManager::EventType type, Network *network, const QByteArray &data)
+ explicit NetworkDataEvent(EventManager::EventType type, Network *network, QByteArray data)
: NetworkEvent(type, network),
- _data(data)
+ _data(std::move(data))
{}
inline QByteArray data() const { return _data; }
public:
explicit NetworkSplitEvent(EventManager::EventType type,
Network *network,
- const QString &channel,
- const QStringList &users,
- const QString &quitMsg)
+ QString channel,
+ QStringList users,
+ QString quitMsg)
: NetworkEvent(type, network),
- _channel(channel),
- _users(users),
- _quitMsg(quitMsg)
+ _channel(std::move(channel)),
+ _users(std::move(users)),
+ _quitMsg(std::move(quitMsg))
{}
inline QString channel() const { return _channel; }
#include <QByteArray>
#include <QDateTime>
#include <QVariantList>
+#include <utility>
#include "quassel.h"
struct RegisterClient : public HandshakeMessage
{
- inline RegisterClient(Quassel::Features clientFeatures, const QString &clientVersion, const QString &buildDate, bool sslSupported = false)
+ inline RegisterClient(Quassel::Features clientFeatures, QString clientVersion, QString buildDate, bool sslSupported = false)
: features(std::move(clientFeatures))
- , clientVersion(clientVersion)
- , buildDate(buildDate)
+ , clientVersion(std::move(clientVersion))
+ , buildDate(std::move(buildDate))
, sslSupported(sslSupported)
{}
struct ClientDenied : public HandshakeMessage
{
- inline ClientDenied(const QString &errorString)
- : errorString(errorString) {}
+ inline ClientDenied(QString errorString)
+ : errorString(std::move(errorString)) {}
QString errorString;
};
struct ClientRegistered : public HandshakeMessage
{
- inline ClientRegistered(Quassel::Features coreFeatures, bool coreConfigured, const QVariantList &backendInfo, const QVariantList &authenticatorInfo, bool sslSupported)
+ inline ClientRegistered(Quassel::Features coreFeatures, bool coreConfigured, QVariantList backendInfo, QVariantList authenticatorInfo, bool sslSupported)
: features(std::move(coreFeatures))
, coreConfigured(coreConfigured)
- , backendInfo(backendInfo)
- , authenticatorInfo(authenticatorInfo)
+ , backendInfo(std::move(backendInfo))
+ , authenticatorInfo(std::move(authenticatorInfo))
, sslSupported(sslSupported)
{}
struct SetupData : public HandshakeMessage
{
- inline SetupData(const QString &adminUser, const QString &adminPassword, const QString &backend,
- const QVariantMap &setupData, const QString &authenticator = QString(),
- const QVariantMap &authSetupData = QVariantMap())
- : adminUser(adminUser)
- , adminPassword(adminPassword)
- , backend(backend)
- , setupData(setupData)
- , authenticator(authenticator)
- , authSetupData(authSetupData)
+ inline SetupData(QString adminUser, QString adminPassword, QString backend,
+ QVariantMap setupData, QString authenticator = QString(),
+ QVariantMap authSetupData = QVariantMap())
+ : adminUser(std::move(adminUser))
+ , adminPassword(std::move(adminPassword))
+ , backend(std::move(backend))
+ , setupData(std::move(setupData))
+ , authenticator(std::move(authenticator))
+ , authSetupData(std::move(authSetupData))
{}
QString adminUser;
struct SetupFailed : public HandshakeMessage
{
- inline SetupFailed(const QString &errorString)
- : errorString(errorString) {}
+ inline SetupFailed(QString errorString)
+ : errorString(std::move(errorString)) {}
QString errorString;
};
struct Login : public HandshakeMessage
{
- inline Login(const QString &user, const QString &password)
- : user(user), password(password) {}
+ inline Login(QString user, QString password)
+ : user(std::move(user)), password(std::move(password)) {}
QString user;
QString password;
struct LoginFailed : public HandshakeMessage
{
- inline LoginFailed(const QString &errorString)
- : errorString(errorString) {}
+ inline LoginFailed(QString errorString)
+ : errorString(std::move(errorString)) {}
QString errorString;
};
struct SessionState : public HandshakeMessage
{
inline SessionState() {} // needed for QMetaType (for the mono client)
- inline SessionState(const QVariantList &identities, const QVariantList &bufferInfos, const QVariantList &networkIds)
- : identities(identities), bufferInfos(bufferInfos), networkIds(networkIds) {}
+ inline SessionState(QVariantList identities, QVariantList bufferInfos, QVariantList networkIds)
+ : identities(std::move(identities)), bufferInfos(std::move(bufferInfos)), networkIds(std::move(networkIds)) {}
QVariantList identities;
QVariantList bufferInfos;
struct SyncMessage : public SignalProxyMessage
{
SyncMessage() = default;
- SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms)
- : className(className), objectName(objectName), slotName(slotName), params(params) {}
+ SyncMessage(QByteArray className, QString objectName, QByteArray slotName, QVariantList params)
+ : className(std::move(className)), objectName(std::move(objectName)), slotName(std::move(slotName)), params(std::move(params)) {}
QByteArray className;
QString objectName;
struct RpcCall : public SignalProxyMessage
{
RpcCall() = default;
- RpcCall(const QByteArray &slotName, const QVariantList ¶ms)
- : slotName(slotName), params(params) {}
+ RpcCall(QByteArray slotName, QVariantList params)
+ : slotName(std::move(slotName)), params(std::move(params)) {}
QByteArray slotName;
QVariantList params;
struct InitRequest : public SignalProxyMessage
{
InitRequest() = default;
- InitRequest(const QByteArray &className, const QString &objectName)
- : className(className), objectName(objectName) {}
+ InitRequest(QByteArray className, QString objectName)
+ : className(std::move(className)), objectName(std::move(objectName)) {}
QByteArray className;
QString objectName;
struct InitData : public SignalProxyMessage
{
InitData() = default;
- InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
- : className(className), objectName(objectName), initData(initData) {}
+ InitData(QByteArray className, QString objectName, QVariantMap initData)
+ : className(std::move(className)), objectName(std::move(objectName)), initData(std::move(initData)) {}
QByteArray className;
QString objectName;
struct HeartBeat
{
- inline HeartBeat(const QDateTime ×tamp) : timestamp(timestamp) {}
+ inline HeartBeat(QDateTime timestamp) : timestamp(std::move(timestamp)) {}
QDateTime timestamp;
};
struct HeartBeatReply
{
- inline HeartBeatReply(const QDateTime ×tamp) : timestamp(timestamp) {}
+ inline HeartBeatReply(QDateTime timestamp) : timestamp(std::move(timestamp)) {}
QDateTime timestamp;
};
#include <QSettings>
#include <QString>
#include <QVariant>
+#include <utility>
#include "quassel.h"
bool isWritable();
protected:
- inline Settings(QString group_, QString appName_) : group(group_), appName(appName_) {}
+ inline Settings(QString group_, QString appName_) : group(std::move(group_)), appName(std::move(appName_)) {}
inline virtual ~Settings() {}
inline void setGroup(const QString &group_) { group = group_; }
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
+#include <utility>
+
#include <QCoreApplication>
#include <QHostAddress>
#include <QMetaMethod>
QObject *sender;
int signalId;
QByteArray signature;
- Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {}
+ Signal(QObject *sender, int sigId, QByteArray signature) : sender(sender), signalId(sigId), signature(std::move(signature)) {}
Signal() : sender(nullptr), signalId(-1) {}
};
#include "transfer.h"
+#include <utility>
+
Transfer::Transfer(const QUuid &uuid, QObject *parent)
: SyncableObject(parent),
_status(Status::New),
init();
}
-Transfer::Transfer(Direction direction, const QString &nick, const QString &fileName, const QHostAddress &address, quint16 port, quint64 fileSize, QObject *parent)
+Transfer::Transfer(Direction direction, QString nick, QString fileName, const QHostAddress &address, quint16 port, quint64 fileSize, QObject *parent)
: SyncableObject(parent),
_status(Status::New),
_direction(direction),
- _fileName(fileName),
+ _fileName(std::move(fileName)),
_address(address),
_port(port),
_fileSize(fileSize),
- _nick(nick),
+ _nick(std::move(nick)),
_uuid(QUuid::createUuid())
{
init();
Q_ENUMS(Direction)
Transfer(const QUuid &uuid, QObject *parent = nullptr); // for creating a syncable object client-side
- Transfer(Direction direction, const QString &nick, const QString &fileName, const QHostAddress &address, quint16 port, quint64 size = 0, QObject *parent = nullptr);
+ Transfer(Direction direction, QString nick, QString fileName, const QHostAddress &address, quint16 port, quint64 size = 0, QObject *parent = nullptr);
QUuid uuid() const;
Status status() const;
#include <QSet>
#include <QString>
#include <QVariant>
+#include <utility>
#include "coreinfo.h"
#include "corealiasmanager.h"
QString text;
QString sender;
Message::Flags flags;
- RawMessage(NetworkId networkId, Message::Type type, BufferInfo::Type bufferType, const QString &target, const QString &text, const QString &sender, Message::Flags flags)
- : networkId(networkId), type(type), bufferType(bufferType), target(target), text(text), sender(sender), flags(flags) {}
+ RawMessage(NetworkId networkId, Message::Type type, BufferInfo::Type bufferType, QString target, QString text, QString sender, Message::Flags flags)
+ : networkId(networkId), type(type), bufferType(bufferType), target(std::move(target)), text(std::move(text)), sender(std::move(sender)), flags(flags) {}
};
#ifndef COREUSERINPUTHANDLER_H
#define COREUSERINPUTHANDLER_H
+#include <utility>
+
#include "corebasichandler.h"
#include "corenetwork.h"
struct Command {
BufferInfo bufferInfo;
QString command;
- Command(const BufferInfo &info, const QString &command) : bufferInfo(info), command(command) {}
+ Command(BufferInfo info, QString command) : bufferInfo(std::move(info)), command(std::move(command)) {}
Command() {}
};
#define CTCPPARSER_H
#include <QUuid>
+#include <utility>
#include "corenetwork.h"
#include "eventmanager.h"
QList<QByteArray> replies;
CtcpReply() : network(nullptr) {}
- CtcpReply(CoreNetwork *net, const QString &buf) : network(net), bufferName(buf) {}
+ CtcpReply(CoreNetwork *net, QString buf) : network(net), bufferName(std::move(buf)) {}
};
QHash<QUuid, CtcpReply> _replies;
#ifndef KEYEVENT_H
#define KEYEVENT_H
+#include <utility>
+
#include "ircevent.h"
class KeyEvent : public IrcEvent
Finish
};
- explicit KeyEvent(EventManager::EventType type, Network *network, const QString &prefix, const QString &target,
- ExchangeType exchangeType, const QByteArray &key,
+ explicit KeyEvent(EventManager::EventType type, Network *network, const QString &prefix, QString target,
+ ExchangeType exchangeType, QByteArray key,
const QDateTime ×tamp = QDateTime())
: IrcEvent(type, network, prefix),
_exchangeType(exchangeType),
- _target(target),
- _key(key)
+ _target(std::move(target)),
+ _key(std::move(key))
{
setTimestamp(timestamp);
}
#include "qtui.h"
#include <QTextLayout>
+#include <utility>
class ChatLine;
class ChatView;
Clickable currentClickable;
Clickable activeClickable;
- ContentsChatItemPrivate(const ClickableList &c, ContentsChatItem *parent) : contentsItem(parent), clickables(c) {}
+ ContentsChatItemPrivate(ClickableList c, ContentsChatItem *parent) : contentsItem(parent), clickables(std::move(c)) {}
};
class ContentsChatItem::WrapColumnFinder
#include "chatscene.h"
+#include <utility>
+
#include <QApplication>
#include <QClipboard>
#include <QDesktopServices>
const qreal minContentsWidth = 200;
-ChatScene::ChatScene(QAbstractItemModel *model, const QString &idString, qreal width, ChatView *parent)
+ChatScene::ChatScene(QAbstractItemModel *model, QString idString, qreal width, ChatView *parent)
: QGraphicsScene(0, 0, width, 0, (QObject *)parent),
_chatView(parent),
- _idString(idString),
+ _idString(std::move(idString)),
_model(model),
_singleBufferId(BufferId()),
_sceneRect(0, 0, width, 0),
TripleClick
};
- ChatScene(QAbstractItemModel *model, const QString &idString, qreal width, ChatView *parent);
+ ChatScene(QAbstractItemModel *model, QString idString, qreal width, ChatView *parent);
~ChatScene() override;
inline QAbstractItemModel *model() const { return _model; }
#define QTUIMESSAGEPROCESSOR_H_
#include <QTimer>
+#include <utility>
#include "abstractmessageprocessor.h"
#include "expressionmatch.h"
*/
LegacyHighlightRule(QString contents, bool isRegEx, bool isCaseSensitive, bool isEnabled,
QString chanName)
- : _contents(contents), _isRegEx(isRegEx), _isCaseSensitive(isCaseSensitive),
- _isEnabled(isEnabled), _chanName(chanName)
+ : _contents(std::move(contents)), _isRegEx(isRegEx), _isCaseSensitive(isCaseSensitive),
+ _isEnabled(isEnabled), _chanName(std::move(chanName))
{
_cacheInvalid = true;
// Cache expression matches on construction
#include "bufferviewsettingspage.h"
#include <QMessageBox>
+#include <utility>
#include "buffermodel.h"
#include "bufferviewconfig.h"
/**************************************************************************
* BufferViewEditDlg
*************************************************************************/
-BufferViewEditDlg::BufferViewEditDlg(const QString &old, const QStringList &exist, QWidget *parent) : QDialog(parent), existing(exist)
+BufferViewEditDlg::BufferViewEditDlg(const QString &old, QStringList exist, QWidget *parent) : QDialog(parent), existing(std::move(exist))
{
ui.setupUi(this);
Q_OBJECT
public:
- BufferViewEditDlg(const QString &old, const QStringList &existing = QStringList(), QWidget *parent = nullptr);
+ BufferViewEditDlg(const QString &old, QStringList existing = QStringList(), QWidget *parent = nullptr);
inline QString bufferViewName() const { return ui.bufferViewEdit->text(); }
#include <QInputDialog>
#include <QMessageBox>
+#include <utility>
#include "client.h"
#include "icon.h"
/*************************************************************************************************/
-NickEditDlg::NickEditDlg(const QString &old, const QStringList &exist, QWidget *parent)
- : QDialog(parent), oldNick(old), existing(exist)
+NickEditDlg::NickEditDlg(const QString &old, QStringList exist, QWidget *parent)
+ : QDialog(parent), oldNick(old), existing(std::move(exist))
{
ui.setupUi(this);
Q_OBJECT
public:
- NickEditDlg(const QString &oldnick, const QStringList &existing = QStringList(), QWidget *parent = nullptr);
+ NickEditDlg(const QString &oldnick, QStringList existing = QStringList(), QWidget *parent = nullptr);
QString nick() const;
#include <QHeaderView>
#include <QMessageBox>
#include <QTextCodec>
+#include <utility>
#include "networkssettingspage.h"
* NetworkAddDlg
*************************************************************************/
-NetworkAddDlg::NetworkAddDlg(const QStringList &exist, QWidget *parent) : QDialog(parent), existing(exist)
+NetworkAddDlg::NetworkAddDlg(QStringList exist, QWidget *parent) : QDialog(parent), existing(std::move(exist))
{
ui.setupUi(this);
ui.useSSL->setIcon(icon::get("document-encrypt"));
* NetworkEditDlg
*************************************************************************/
-NetworkEditDlg::NetworkEditDlg(const QString &old, const QStringList &exist, QWidget *parent) : QDialog(parent), existing(exist)
+NetworkEditDlg::NetworkEditDlg(const QString &old, QStringList exist, QWidget *parent) : QDialog(parent), existing(std::move(exist))
{
ui.setupUi(this);
Q_OBJECT
public:
- NetworkAddDlg(const QStringList &existing = QStringList(), QWidget *parent = nullptr);
+ NetworkAddDlg(QStringList existing = QStringList(), QWidget *parent = nullptr);
NetworkInfo networkInfo() const;
Q_OBJECT
public:
- NetworkEditDlg(const QString &old, const QStringList &existing = QStringList(), QWidget *parent = nullptr);
+ NetworkEditDlg(const QString &old, QStringList existing = QStringList(), QWidget *parent = nullptr);
QString networkName() const;
#include "aboutdata.h"
#include <QImage>
+#include <utility>
#include "quassel.h"
-AboutPerson::AboutPerson(const QString &name, const QString &nick, const QString &task, const QString &emailAddress, QLocale::Language translatedLanguage)
- : _name(name)
- , _nick(nick)
- , _task(task)
- , _emailAddress(emailAddress)
+AboutPerson::AboutPerson(QString name, QString nick, QString task, QString emailAddress, QLocale::Language translatedLanguage)
+ : _name(std::move(name))
+ , _nick(std::move(nick))
+ , _task(std::move(task))
+ , _emailAddress(std::move(emailAddress))
, _language(translatedLanguage)
{
* @param[in] emailAddress The person's email address, if applicable
* @param[in] translatedLanguage The language the person helped translate (only applicable for translators)
*/
- AboutPerson(const QString &name, const QString &nick, const QString &task, const QString &emailAddress = QString(), QLocale::Language translatedLanguage = QLocale::C);
+ AboutPerson(QString name, QString nick, QString task, QString emailAddress = QString(), QLocale::Language translatedLanguage = QLocale::C);
/**
* Gets the person's name.
#include <QObject>
#include <QString>
+#include <utility>
#include "bufferinfo.h"
QString sender;
QString message;
- Notification(uint id_, BufferId buf_, NotificationType type_, const QString &sender_, const QString &msg_)
- : notificationId(id_), bufferId(buf_), type(type_), sender(sender_), message(msg_) {};
+ Notification(uint id_, BufferId buf_, NotificationType type_, QString sender_, QString msg_)
+ : notificationId(id_), bufferId(buf_), type(type_), sender(std::move(sender_)), message(std::move(msg_)) {};
};
inline AbstractNotificationBackend(QObject *parent) : QObject(parent) {};
#include <QComboBox>
#include <QSpinBox>
#include <QVariant>
+#include <utility>
#include "fontselector.h"
#include "uisettings.h"
-SettingsPage::SettingsPage(const QString &category, const QString &title, QWidget *parent)
+SettingsPage::SettingsPage(QString category, QString title, QWidget *parent)
: QWidget(parent),
- _category(category),
- _title(title),
+ _category(std::move(category)),
+ _title(std::move(title)),
_changed(false),
_autoWidgetsChanged(false)
{
Q_OBJECT
public:
- SettingsPage(const QString &category, const QString &name, QWidget *parent = nullptr);
+ SettingsPage(QString category, QString name, QWidget *parent = nullptr);
~SettingsPage() override {};
//! The category of this settings page.
#include "uisettings.h"
+#include <utility>
+
#include "action.h"
#include "actioncollection.h"
* SessionSettings
**************************************************************************/
-SessionSettings::SessionSettings(const QString &sessionId, const QString &group)
- : UiSettings(group), _sessionId(sessionId)
+SessionSettings::SessionSettings(QString sessionId, const QString &group)
+ : UiSettings(group), _sessionId(std::move(sessionId))
{
}
class UISUPPORT_EXPORT SessionSettings : public UiSettings
{
public:
- SessionSettings(const QString &sessionId, const QString &group = "Session");
+ SessionSettings(QString sessionId, const QString &group = "Session");
void setValue(const QString &key, const QVariant &data) override;
QVariant value(const QString &key, const QVariant &def = QVariant()) override;