Add /raw as an alias for /quote
[quassel.git] / src / client / clientbacklogmanager.cpp
1 /***************************************************************************
2  *   Copyright (C) 2005-2020 by the Quassel Project                        *
3  *   devel@quassel-irc.org                                                 *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) version 3.                                           *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
19  ***************************************************************************/
20
21 #include "clientbacklogmanager.h"
22
23 #include <algorithm>
24 #include <ctime>
25
26 #include <QDebug>
27
28 #include "abstractmessageprocessor.h"
29 #include "backlogrequester.h"
30 #include "backlogsettings.h"
31 #include "client.h"
32 #include "util.h"
33
34 ClientBacklogManager::ClientBacklogManager(QObject* parent)
35     : BacklogManager(parent)
36 {}
37
38 QVariantList ClientBacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional)
39 {
40     _buffersRequested << bufferId;
41     return BacklogManager::requestBacklog(bufferId, first, last, limit, additional);
42 }
43
44 void ClientBacklogManager::receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional, QVariantList msgs)
45 {
46     Q_UNUSED(first)
47     Q_UNUSED(last)
48     Q_UNUSED(limit)
49     Q_UNUSED(additional)
50
51     emit messagesReceived(bufferId, msgs.count());
52
53     MessageList msglist;
54     foreach (QVariant v, msgs) {
55         Message msg = v.value<Message>();
56         msg.setFlags(msg.flags() | Message::Backlog);
57         msglist << msg;
58     }
59
60     if (isBuffering()) {
61         bool lastPart = !_requester->buffer(bufferId, msglist);
62         updateProgress(_requester->totalBuffers() - _requester->buffersWaiting(), _requester->totalBuffers());
63         if (lastPart) {
64             dispatchMessages(_requester->bufferedMessages(), true);
65             _requester->flushBuffer();
66         }
67     }
68     else {
69         dispatchMessages(msglist);
70     }
71 }
72
73 void ClientBacklogManager::receiveBacklogAll(MsgId first, MsgId last, int limit, int additional, QVariantList msgs)
74 {
75     Q_UNUSED(first)
76     Q_UNUSED(last)
77     Q_UNUSED(limit)
78     Q_UNUSED(additional)
79
80     MessageList msglist;
81     foreach (QVariant v, msgs) {
82         Message msg = v.value<Message>();
83         msg.setFlags(msg.flags() | Message::Backlog);
84         msglist << msg;
85     }
86
87     dispatchMessages(msglist);
88 }
89
90 void ClientBacklogManager::requestInitialBacklog()
91 {
92     if (_initBacklogRequested) {
93         Q_ASSERT(_requester);
94         qWarning() << "ClientBacklogManager::requestInitialBacklog() called twice in the same session! (Backlog has already been requested)";
95         return;
96     }
97
98     BacklogSettings settings;
99     switch (settings.requesterType()) {
100     case BacklogRequester::AsNeeded:
101         _requester = new AsNeededBacklogRequester(this);
102         break;
103     case BacklogRequester::GlobalUnread:
104         _requester = new GlobalUnreadBacklogRequester(this);
105         break;
106     case BacklogRequester::PerBufferUnread:
107         _requester = new PerBufferUnreadBacklogRequester(this);
108         break;
109     case BacklogRequester::PerBufferFixed:
110     default:
111         _requester = new FixedBacklogRequester(this);
112     };
113
114     _requester->requestInitialBacklog();
115     _initBacklogRequested = true;
116     if (_requester->isBuffering()) {
117         updateProgress(0, _requester->totalBuffers());
118     }
119 }
120
121 BufferIdList ClientBacklogManager::filterNewBufferIds(const BufferIdList& bufferIds)
122 {
123     BufferIdList newBuffers;
124     QSet<BufferId> availableBuffers = toQSet(Client::networkModel()->allBufferIds());
125     foreach (BufferId bufferId, bufferIds) {
126         if (_buffersRequested.contains(bufferId) || !availableBuffers.contains(bufferId))
127             continue;
128         newBuffers << bufferId;
129     }
130     return newBuffers;
131 }
132
133 void ClientBacklogManager::checkForBacklog(const QList<BufferId>& bufferIds)
134 {
135     // we ingore all backlogrequests until we had our initial request
136     if (!_initBacklogRequested) {
137         return;
138     }
139
140     if (!_requester) {
141         // during client start up this message is to be expected in some situations.
142         qDebug() << "ClientBacklogManager::checkForBacklog(): no active backlog requester.";
143         return;
144     }
145     switch (_requester->type()) {
146     case BacklogRequester::GlobalUnread:
147         break;
148     case BacklogRequester::PerBufferUnread:
149     case BacklogRequester::PerBufferFixed:
150     case BacklogRequester::AsNeeded:
151     default: {
152         BufferIdList buffers = filterNewBufferIds(bufferIds);
153         if (!buffers.isEmpty())
154             _requester->requestBacklog(buffers);
155     }
156     };
157 }
158
159 bool ClientBacklogManager::isBuffering()
160 {
161     return _requester && _requester->isBuffering();
162 }
163
164 void ClientBacklogManager::dispatchMessages(const MessageList& messages, bool sort)
165 {
166     if (messages.isEmpty())
167         return;
168
169     MessageList msgs = messages;
170
171     clock_t start_t = clock();
172     if (sort)
173         std::sort(msgs.begin(), msgs.end());
174     Client::messageProcessor()->process(msgs);
175     clock_t end_t = clock();
176
177     emit messagesProcessed(tr("Processed %1 messages in %2 seconds.").arg(messages.count()).arg((float)(end_t - start_t) / CLOCKS_PER_SEC));
178 }
179
180 void ClientBacklogManager::reset()
181 {
182     delete _requester;
183     _requester = nullptr;
184     _initBacklogRequested = false;
185     _buffersRequested.clear();
186 }