65 } |
65 } |
66 |
66 |
67 |
67 |
68 void MessagingHelper::filterAccounts(QMessageAccountIdList& accountIds, const QMessageAccountFilter& filter) |
68 void MessagingHelper::filterAccounts(QMessageAccountIdList& accountIds, const QMessageAccountFilter& filter) |
69 { |
69 { |
70 QMessageAccountFilterPrivate* pf = QMessageAccountFilterPrivate::implementation(filter); |
70 if (accountIds.count() && !filter.isEmpty()) { |
71 if ((pf->_field == QMessageAccountFilterPrivate::None) && |
71 QMessageAccountFilterPrivate* pf = QMessageAccountFilterPrivate::implementation(filter); |
72 (pf->_filterList.count() == 0)) { |
72 if ((pf->_field == QMessageAccountFilterPrivate::None) && |
73 if (pf->_notFilter) { |
73 (pf->_filterList.count() == 0)) { |
74 // There is only one filter: empty ~QMessageFilter() |
74 if (pf->_notFilter) { |
75 // => accountIds must be cleared |
75 // There is only one filter: empty ~QMessageFilter() |
76 accountIds.clear(); |
76 // => accountIds must be cleared |
77 return; |
77 accountIds.clear(); |
78 } else { |
78 return; |
79 // There is only one filter: empty QMessageFilter() |
79 } else { |
80 // => accountIds list can remain intact |
80 // There is only one filter: empty QMessageFilter() |
81 return; |
81 // => accountIds list can remain intact |
82 } |
82 return; |
83 } |
83 } |
84 |
84 } |
85 if (pf->_valid) { |
85 |
86 QMessageStore* store = QMessageStore::instance(); |
86 if (pf->_valid) { |
87 for (int i=accountIds.count()-1; i >= 0; i--) { |
87 QMessageStore* store = QMessageStore::instance(); |
88 QMessageAccount account = store->account(accountIds[i]); |
88 for (int i=accountIds.count()-1; i >= 0; i--) { |
89 if (!pf->filter(account)) { |
89 QMessageAccount account = store->account(accountIds[i]); |
90 accountIds.removeAt(i); |
90 if (!pf->filter(account)) { |
|
91 accountIds.removeAt(i); |
|
92 } |
91 } |
93 } |
92 } |
94 } |
93 } |
95 } |
94 } |
96 } |
95 |
97 |
101 store->account(accountId2)); |
103 store->account(accountId2)); |
102 } |
104 } |
103 |
105 |
104 void MessagingHelper::orderAccounts(QMessageAccountIdList& accountIds, const QMessageAccountSortOrder &sortOrder) |
106 void MessagingHelper::orderAccounts(QMessageAccountIdList& accountIds, const QMessageAccountSortOrder &sortOrder) |
105 { |
107 { |
106 messagingHelper()->m_AccountSortOrder = (QMessageAccountSortOrder*)&sortOrder; |
108 if (!sortOrder.isEmpty()) { |
107 qSort(accountIds.begin(), accountIds.end(), MessagingHelper::accountLessThan); |
109 messagingHelper()->m_AccountSortOrder = (QMessageAccountSortOrder*)&sortOrder; |
|
110 qSort(accountIds.begin(), accountIds.end(), MessagingHelper::accountLessThan); |
|
111 } |
108 } |
112 } |
109 |
113 |
110 void MessagingHelper::applyOffsetAndLimitToAccountIdList(QMessageAccountIdList& accountIds, int limit, int offset) |
114 void MessagingHelper::applyOffsetAndLimitToAccountIdList(QMessageAccountIdList& accountIds, int limit, int offset) |
111 { |
115 { |
|
116 if (accountIds.count() == 0) { |
|
117 return; |
|
118 } |
|
119 |
112 if (offset > 0) { |
120 if (offset > 0) { |
113 if (offset > accountIds.count()) { |
121 if (offset > accountIds.count()) { |
114 accountIds.clear(); |
122 accountIds.clear(); |
115 } else { |
123 } else { |
116 for (int i = 0; i < offset; i++) { |
124 for (int i = 0; i < offset; i++) { |
125 } |
133 } |
126 } |
134 } |
127 |
135 |
128 void MessagingHelper::filterFolders(QMessageFolderIdList& folderIds, const QMessageFolderFilter& filter) |
136 void MessagingHelper::filterFolders(QMessageFolderIdList& folderIds, const QMessageFolderFilter& filter) |
129 { |
137 { |
130 QMessageFolderFilterPrivate* pf = QMessageFolderFilterPrivate::implementation(filter); |
138 if (folderIds.count() && !filter.isEmpty()) { |
131 if ((pf->_field == QMessageFolderFilterPrivate::None) && |
139 QMessageFolderFilterPrivate* pf = QMessageFolderFilterPrivate::implementation(filter); |
132 (pf->_filterList.count() == 0)) { |
140 if ((pf->_field == QMessageFolderFilterPrivate::None) && |
133 if (pf->_notFilter) { |
141 (pf->_filterList.count() == 0)) { |
134 // There is only one filter: empty ~QMessageFilter() |
142 if (pf->_notFilter) { |
135 // => accountIds must be cleared |
143 // There is only one filter: empty ~QMessageFilter() |
136 folderIds.clear(); |
144 // => accountIds must be cleared |
137 return; |
145 folderIds.clear(); |
138 } else { |
146 return; |
139 // There is only one filter: empty QMessageFilter() |
147 } else { |
140 // => accountIds list can remain intact |
148 // There is only one filter: empty QMessageFilter() |
141 return; |
149 // => accountIds list can remain intact |
142 } |
150 return; |
143 } |
151 } |
144 |
152 } |
145 if (pf->_valid) { |
153 |
146 QMessageStore* store = QMessageStore::instance(); |
154 if (pf->_valid) { |
147 for (int i=folderIds.count()-1; i >= 0; i--) { |
155 QMessageStore* store = QMessageStore::instance(); |
148 QMessageFolder folder = store->folder(folderIds[i]); |
156 for (int i=folderIds.count()-1; i >= 0; i--) { |
149 if (!pf->filter(folder)) { |
157 QMessageFolder folder = store->folder(folderIds[i]); |
150 folderIds.removeAt(i); |
158 if (!pf->filter(folder)) { |
|
159 folderIds.removeAt(i); |
|
160 } |
151 } |
161 } |
152 } |
162 } |
153 } |
163 } |
154 } |
164 } |
155 |
165 |
161 store->folder(folderId2)); |
171 store->folder(folderId2)); |
162 } |
172 } |
163 |
173 |
164 void MessagingHelper::orderFolders(QMessageFolderIdList& folderIds, const QMessageFolderSortOrder &sortOrder) |
174 void MessagingHelper::orderFolders(QMessageFolderIdList& folderIds, const QMessageFolderSortOrder &sortOrder) |
165 { |
175 { |
166 messagingHelper()->m_FolderSortOrder = (QMessageFolderSortOrder*)&sortOrder; |
176 if (!sortOrder.isEmpty()) { |
167 qSort(folderIds.begin(), folderIds.end(), MessagingHelper::folderLessThan); |
177 messagingHelper()->m_FolderSortOrder = (QMessageFolderSortOrder*)&sortOrder; |
|
178 qSort(folderIds.begin(), folderIds.end(), MessagingHelper::folderLessThan); |
|
179 } |
168 } |
180 } |
169 |
181 |
170 void MessagingHelper::applyOffsetAndLimitToFolderIdList(QMessageFolderIdList& folderIds, int limit, int offset) |
182 void MessagingHelper::applyOffsetAndLimitToFolderIdList(QMessageFolderIdList& folderIds, int limit, int offset) |
171 { |
183 { |
|
184 if (folderIds.count() == 0) { |
|
185 return; |
|
186 } |
|
187 |
172 if (offset > 0) { |
188 if (offset > 0) { |
173 if (offset > folderIds.count()) { |
189 if (offset > folderIds.count()) { |
174 folderIds.clear(); |
190 folderIds.clear(); |
175 } else { |
191 } else { |
176 for (int i = 0; i < offset; i++) { |
192 for (int i = 0; i < offset; i++) { |
185 } |
201 } |
186 } |
202 } |
187 |
203 |
188 void MessagingHelper::filterMessages(QMessageIdList& messageIds, const QMessageFilter& filter) |
204 void MessagingHelper::filterMessages(QMessageIdList& messageIds, const QMessageFilter& filter) |
189 { |
205 { |
190 QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(filter); |
206 if (messageIds.count() && !filter.isEmpty()) { |
191 if ((pf->_field == QMessageFilterPrivate::None) && |
207 QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(filter); |
192 (pf->_filterList.count() == 0)) { |
208 if ((pf->_field == QMessageFilterPrivate::None) && |
193 if (pf->_notFilter) { |
209 (pf->_filterList.count() == 0)) { |
194 // There is only one filter: empty ~QMessageFilter() |
210 if (pf->_notFilter) { |
195 // => accountIds must be cleared |
211 // There is only one filter: empty ~QMessageFilter() |
196 messageIds.clear(); |
212 // => accountIds must be cleared |
197 return; |
213 messageIds.clear(); |
198 } else { |
214 return; |
199 // There is only one filter: empty QMessageFilter() |
215 } else { |
200 // => accountIds list can remain intact |
216 // There is only one filter: empty QMessageFilter() |
201 return; |
217 // => accountIds list can remain intact |
202 } |
218 return; |
203 } |
219 } |
204 |
220 } |
205 if (pf->_valid) { |
221 |
206 QMessageStore* store = QMessageStore::instance(); |
222 if (pf->_valid) { |
207 for (int i=messageIds.count()-1; i >= 0; i--) { |
223 QMessageStore* store = QMessageStore::instance(); |
208 QMessage message = store->message(messageIds[i]); |
224 for (int i=messageIds.count()-1; i >= 0; i--) { |
209 if (!pf->filter(message)) { |
225 QMessage message = store->message(messageIds[i]); |
210 messageIds.removeAt(i); |
226 if (!pf->filter(message)) { |
|
227 messageIds.removeAt(i); |
|
228 } |
211 } |
229 } |
212 } |
230 } |
213 } |
231 } |
214 } |
232 } |
215 |
233 |
221 store->message(messageId2)); |
239 store->message(messageId2)); |
222 } |
240 } |
223 |
241 |
224 void MessagingHelper::orderMessages(QMessageIdList& messageIds, const QMessageSortOrder &sortOrder) |
242 void MessagingHelper::orderMessages(QMessageIdList& messageIds, const QMessageSortOrder &sortOrder) |
225 { |
243 { |
226 messagingHelper()->m_MessageSortOrder = (QMessageSortOrder*)&sortOrder; |
244 if (!sortOrder.isEmpty()) { |
227 qSort(messageIds.begin(), messageIds.end(), MessagingHelper::messageLessThan); |
245 messagingHelper()->m_MessageSortOrder = (QMessageSortOrder*)&sortOrder; |
|
246 qSort(messageIds.begin(), messageIds.end(), MessagingHelper::messageLessThan); |
|
247 } |
228 } |
248 } |
229 |
249 |
230 void MessagingHelper::applyOffsetAndLimitToMessageIdList(QMessageIdList& messageIds, int limit, int offset) |
250 void MessagingHelper::applyOffsetAndLimitToMessageIdList(QMessageIdList& messageIds, int limit, int offset) |
231 { |
251 { |
|
252 if (messageIds.count() == 0) { |
|
253 return; |
|
254 } |
|
255 |
232 if (offset > 0) { |
256 if (offset > 0) { |
233 if (offset > messageIds.count()) { |
257 if (offset > messageIds.count()) { |
234 messageIds.clear(); |
258 messageIds.clear(); |
235 } else { |
259 } else { |
236 for (int i = 0; i < offset; i++) { |
260 for (int i = 0; i < offset; i++) { |