: Transfer(uuid, parent),
_file(0)
{
- connect(this, SIGNAL(stateChanged(State)), SLOT(onStateChanged(State)));
+ connect(this, SIGNAL(stateChanged(Transfer::State)), SLOT(onStateChanged(Transfer::State)));
}
void ClientTransfer::onStateChanged(Transfer::State state)
{
switch(state) {
- case Completed:
+ case State::Completed:
if (_file)
_file->close();
break;
- case Failed:
+ case State::Failed:
if (_file)
_file->remove();
break;
private slots:
void dataReceived(PeerPtr peer, const QByteArray &data);
- void onStateChanged(State state);
+ void onStateChanged(Transfer::State state);
private:
virtual void cleanUp();
qRegisterMetaType<MsgId>("MsgId");
qRegisterMetaType<QHostAddress>("QHostAddress");
+ qRegisterMetaTypeStreamOperators<QHostAddress>("QHostAddress");
qRegisterMetaType<QUuid>("QUuid");
+ qRegisterMetaTypeStreamOperators<QUuid>("QUuid");
qRegisterMetaTypeStreamOperators<IdentityId>("IdentityId");
qRegisterMetaTypeStreamOperators<BufferId>("BufferId");
INIT_SYNCABLE_OBJECT(Transfer)
Transfer::Transfer(const QUuid &uuid, QObject *parent)
: SyncableObject(parent),
- _state(New),
- _direction(Receive),
+ _state(State::New),
+ _direction(Direction::Receive),
_port(0),
_fileSize(0),
_uuid(uuid)
Transfer::Transfer(Direction direction, const QString &nick, const QString &fileName, const QHostAddress &address, quint16 port, quint64 fileSize, QObject *parent)
: SyncableObject(parent),
- _state(New),
+ _state(State::New),
_direction(direction),
_fileName(fileName),
_address(address),
void Transfer::init()
{
+ static auto regTypes = []() -> bool {
+ qRegisterMetaType<State>("Transfer::State");
+ qRegisterMetaType<Direction>("Transfer::Direction");
+ qRegisterMetaTypeStreamOperators<State>("Transfer::State");
+ qRegisterMetaTypeStreamOperators<Direction>("Transfer::Direction");
+ return true;
+ }();
+ Q_UNUSED(regTypes);
+
renameObject(QString("Transfer/%1").arg(_uuid.toString()));
setAllowClientUpdates(true);
}
{
qWarning() << Q_FUNC_INFO << errorString;
emit error(errorString);
- setState(Failed);
+ setState(State::Failed);
cleanUp();
}
+
+
+QDataStream &operator<<(QDataStream &out, Transfer::State state) {
+ out << static_cast<qint8>(state);
+ return out;
+}
+
+QDataStream &operator>>(QDataStream &in, Transfer::State &state) {
+ qint8 s;
+ in >> s;
+ state = static_cast<Transfer::State>(s);
+ return in;
+}
+
+QDataStream &operator<<(QDataStream &out, Transfer::Direction direction) {
+ out << static_cast<qint8>(direction);
+ return out;
+}
+
+QDataStream &operator>>(QDataStream &in, Transfer::Direction &direction) {
+ qint8 d;
+ in >> d;
+ direction = static_cast<Transfer::Direction>(d);
+ return in;
+}
SYNCABLE_OBJECT
Q_PROPERTY(QUuid uuid READ uuid);
- Q_PROPERTY(State state READ state WRITE setState NOTIFY stateChanged);
- Q_PROPERTY(Direction direction READ direction WRITE setDirection NOTIFY directionChanged);
+ Q_PROPERTY(Transfer::State state READ state WRITE setState NOTIFY stateChanged);
+ Q_PROPERTY(Transfer::Direction direction READ direction WRITE setDirection NOTIFY directionChanged);
Q_PROPERTY(QHostAddress address READ address WRITE setAddress NOTIFY addressChanged);
Q_PROPERTY(quint16 port READ port WRITE setPort NOTIFY portChanged);
Q_PROPERTY(QString fileName READ fileName WRITE setFileName NOTIFY fileNameChanged);
Q_PROPERTY(QString nick READ nick WRITE setNick NOTIFY nickChanged);
public:
- enum State {
+ enum class State {
New,
Pending,
Connecting,
};
Q_ENUMS(State)
- enum Direction {
+ enum class Direction {
Send,
Receive
};
virtual void requestRejected(PeerPtr peer) { Q_UNUSED(peer); }
signals:
- void stateChanged(State state);
- void directionChanged(Direction direction);
+ void stateChanged(Transfer::State state);
+ void directionChanged(Transfer::Direction direction);
void addressChanged(const QHostAddress &address);
void portChanged(quint16 port);
void fileNameChanged(const QString &fileName);
void rejected(PeerPtr peer = 0) const;
protected slots:
- void setState(State state);
+ void setState(Transfer::State state);
void setError(const QString &errorString);
// called on the client side through sync calls
QUuid _uuid;
};
+Q_DECLARE_METATYPE(Transfer::State)
+Q_DECLARE_METATYPE(Transfer::Direction)
+
+QDataStream &operator<<(QDataStream &out, Transfer::State state);
+QDataStream &operator>>(QDataStream &in, Transfer::State &state);
+QDataStream &operator<<(QDataStream &out, Transfer::Direction direction);
+QDataStream &operator>>(QDataStream &in, Transfer::Direction &direction);
+
#endif
}
// TODO: check if target is the right thing to use for the partner
- CoreTransfer *transfer = new CoreTransfer(Transfer::Receive, e->target(), filename, address, port, size, this);
+ CoreTransfer *transfer = new CoreTransfer(Transfer::Direction::Receive, e->target(), filename, address, port, size, this);
coreSession()->signalProxy()->synchronize(transfer);
coreSession()->transferManager()->addTransfer(transfer);
}
void CoreTransfer::onSocketDisconnected()
{
- if (state() == Connecting || state() == Transferring) {
+ if (state() == State::Connecting || state() == State::Transferring) {
setError(tr("Socket closed while still transferring!"));
}
else
{
Q_UNUSED(error)
- if (state() == Connecting || state() == Transferring) {
+ if (state() == State::Connecting || state() == State::Transferring) {
setError(tr("DCC connection error: %1").arg(_socket->errorString()));
}
}
void CoreTransfer::requestAccepted(PeerPtr peer)
{
- if (_peer || !peer || state() != New)
+ if (_peer || !peer || state() != State::New)
return; // transfer was already accepted
_peer = peer;
- setState(Pending);
+ setState(State::Pending);
emit accepted(peer);
void CoreTransfer::requestRejected(PeerPtr peer)
{
- if (_peer || state() != New)
+ if (_peer || state() != State::New)
return;
_peer = peer;
- setState(Rejected);
+ setState(State::Rejected);
emit rejected(peer);
}
void CoreTransfer::start()
{
- if (!_peer || state() != Pending || direction() != Receive)
+ if (!_peer || state() != State::Pending || direction() != Direction::Receive)
return;
setupConnectionForReceive();
return;
}
- setState(Connecting);
+ setState(State::Connecting);
_socket = new QTcpSocket(this);
connect(_socket, SIGNAL(connected()), SLOT(startReceiving()));
void CoreTransfer::startReceiving()
{
- setState(Transferring);
+ setState(State::Transferring);
}
else if (_pos == fileSize()) {
qDebug() << "DCC Receive: Transfer finished";
if (relayData(QByteArray(), false)) // empty buffer
- setState(Completed);
+ setState(State::Completed);
}
_reading = false;
// we only want to send data to the client once we have reached the chunksize
if (_buffer.size() > 0 && (_buffer.size() >= chunkSize || !requireChunkSize)) {
- SYNC_OTHER(dataReceived, ARG(_peer), ARG(_buffer));
+ Peer *p = _peer.data();
+ SYNC_OTHER(dataReceived, ARG(p), ARG(_buffer));
_buffer.clear();
}