Akonadi Search
10 #include "searchstore.h"
13 #include <QSharedPointer>
15 #include <QStringList>
19 #include <QJsonDocument>
20 #include <QJsonObject>
24 const int defaultLimit = 100000;
26 class Akonadi::Search::QueryPrivate
33 uint m_limit = defaultLimit;
36 int m_yearFilter = -1;
37 int m_monthFilter = -1;
42 QVariantMap m_customOptions;
50 Query::Query(
const Term &t)
56 Query::Query(
const Query &rhs)
57 : d(new QueryPrivate(*rhs.d))
61 Query::~Query() =
default;
63 void Query::setTerm(
const Term &t)
68 Term Query::term()
const
80 for (
const QString &type : typeList) {
85 void Query::setType(
const QString &type)
101 QString Query::searchString()
const
103 return d->m_searchString;
108 d->m_searchString = str;
111 uint Query::limit()
const
121 uint Query::offset()
const
126 void Query::setOffset(uint offset)
128 d->m_offset = offset;
133 d->m_yearFilter = year;
134 d->m_monthFilter = month;
135 d->m_dayFilter = day;
138 int Query::yearFilter()
const
140 return d->m_yearFilter;
143 int Query::monthFilter()
const
145 return d->m_monthFilter;
148 int Query::dayFilter()
const
150 return d->m_dayFilter;
155 d->m_sortingOption = option;
160 return d->m_sortingOption;
165 d->m_sortingOption = SortProperty;
166 d->m_sortingProperty = property;
169 QString Query::sortingProperty()
const
171 return d->m_sortingProperty;
176 d->m_customOptions.insert(option, value);
181 return d->m_customOptions.
value(option);
184 QVariantMap Query::customOptions()
const
186 return d->m_customOptions;
189 void Query::removeCustomOption(
const QString &option)
191 d->m_customOptions.remove(option);
199 Q_ASSERT_X(!
types().isEmpty(),
"Akonadi::Search::Query::exec",
"A query is being initialized without a type");
200 if (
types().isEmpty()) {
207 const auto typeList{
types()};
208 for (
const QString &type : typeList) {
209 if (!store->types().contains(type)) {
216 storeMatch = store.data();
225 int id = storeMatch->
exec(*
this);
226 return {id, storeMatch};
233 if (!d->m_types.isEmpty()) {
234 map[QStringLiteral(
"type")] = d->m_types;
237 if (d->m_limit != defaultLimit) {
238 map[QStringLiteral(
"limit")] = d->m_limit;
242 map[QStringLiteral(
"offset")] = d->m_offset;
245 if (!d->m_searchString.isEmpty()) {
246 map[QStringLiteral(
"searchString")] = d->m_searchString;
249 if (d->m_term.isValid()) {
250 map[QStringLiteral(
"term")] =
QVariant(d->m_term.toVariantMap());
253 if (d->m_yearFilter >= 0) {
254 map[QStringLiteral(
"yearFilter")] = d->m_yearFilter;
256 if (d->m_monthFilter >= 0) {
257 map[QStringLiteral(
"monthFilter")] = d->m_monthFilter;
259 if (d->m_dayFilter >= 0) {
260 map[QStringLiteral(
"dayFilter")] = d->m_dayFilter;
263 if (d->m_sortingOption != SortAuto) {
264 map[QStringLiteral(
"sortingOption")] =
static_cast<int>(d->m_sortingOption);
266 if (!d->m_sortingProperty.isEmpty()) {
267 map[QStringLiteral(
"sortingProperty")] = d->m_sortingProperty;
270 if (!d->m_customOptions.isEmpty()) {
271 map[QStringLiteral(
"customOptions")] = d->m_customOptions;
287 query.d->m_types =
map[QStringLiteral(
"type")].toStringList();
289 if (
map.contains(QStringLiteral(
"limit"))) {
290 query.d->m_limit =
map[QStringLiteral(
"limit")].toUInt();
292 query.d->m_limit = defaultLimit;
295 query.d->m_offset =
map[QStringLiteral(
"offset")].toUInt();
296 query.d->m_searchString =
map[QStringLiteral(
"searchString")].toString();
297 query.d->m_term = Term::fromVariantMap(map[QStringLiteral(
"term")].
toMap());
299 if (
map.contains(QStringLiteral(
"yearFilter"))) {
300 query.d->m_yearFilter =
map[QStringLiteral(
"yearFilter")].toInt();
302 if (
map.contains(QStringLiteral(
"monthFilter"))) {
303 query.d->m_monthFilter =
map[QStringLiteral(
"monthFilter")].toInt();
305 if (
map.contains(QStringLiteral(
"dayFilter"))) {
306 query.d->m_dayFilter =
map[QStringLiteral(
"dayFilter")].toInt();
309 if (
map.contains(QStringLiteral(
"sortingOption"))) {
310 int option =
map.value(QStringLiteral(
"sortingOption")).toInt();
311 query.d->m_sortingOption =
static_cast<SortingOption
>(option);
314 if (
map.contains(QStringLiteral(
"sortingProperty"))) {
315 query.d->m_sortingProperty =
map.value(QStringLiteral(
"sortingProperty")).
toString();
318 if (
map.contains(QStringLiteral(
"customOptions"))) {
319 QVariant var =
map[QStringLiteral(
"customOptions")];
321 query.d->m_customOptions =
map[QStringLiteral(
"customOptions")].toMap();
323 QVariantHash hash = var.
toHash();
327 for (; it !=
end; ++it) {
328 query.d->m_customOptions.
insert(it.key(), it.value());
339 url.
setScheme(QStringLiteral(
"akonadisearch"));
352 Query Query::fromSearchUrl(
const QUrl &url)
360 return Query::fromJSON(jsonString.
toUtf8());
369 bool Query::operator==(
const Query &rhs)
const
371 if (rhs.d->m_limit != d->m_limit || rhs.d->m_offset != d->m_offset || rhs.d->m_dayFilter != d->m_dayFilter || rhs.d->m_monthFilter != d->m_monthFilter
372 || rhs.d->m_yearFilter != d->m_yearFilter || rhs.d->m_customOptions != d->m_customOptions || rhs.d->m_searchString != d->m_searchString
373 || rhs.d->m_sortingProperty != d->m_sortingProperty || rhs.d->m_sortingOption != d->m_sortingOption) {
377 if (rhs.d->m_types.size() != d->m_types.size()) {
381 for (
const QString &type : std::as_const(rhs.d->m_types)) {
382 if (!d->m_types.contains(type)) {
387 return d->m_term == rhs.d->m_term;
QJsonObject object() const const
@ SortAuto
The results are returned in the order the SearchStore decides should be ideal.
QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error)
QString fromUtf8(const char *str, int size)
QString scheme() const const
void addQueryItem(const QString &key, const QString &value)
QVariantMap toVariantMap() const const
QJsonObject fromVariantMap(const QVariantMap &map)
virtual int exec(const Query &query)=0
Executes the particular query synchronously.
void setScheme(const QString &scheme)
QStringList types(Mode mode=Writing)
KSERVICE_EXPORT KService::List query(FilterFunc filterFunc)
int userType() const const
Akonadi search infrastructure.
void setSortingProperty(const QString &property)
Sets the property that should be used for sorting.
void addType(const QString &type)
Add a type to the results of the query.
bool isEmpty() const const
QByteArray toUtf8() const const
static List searchStores()
Gives a list of available search stores.
void setDateFilter(int year, int month=-1, int day=-1)
Filter the results in the specified date range.
void insert(int i, const T &value)
void setQuery(const QString &query, QUrl::ParsingMode mode)
QByteArray toJson() const const
void setObject(const QJsonObject &object)
const QVariantMap toMap(const MODEL &model)
void setSearchString(const QString &str)
Set some text which should be used to search for Items.
QString queryItemValue(const QString &key, QUrl::ComponentFormattingOptions encoding) const const
void setLimit(uint limit)
Only a maximum of limit results will be returned.
QFuture< void > map(Sequence &sequence, MapFunctor function)
QHash< QString, QVariant > toHash() const const
const QList< QKeySequence > & end()
char * toString(const EngineQuery &query)
void addCustomOption(const QString &option, const QVariant &value)
Adds a custom option which any search backend could use to configure the query result.
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Thu Dec 7 2023 04:11:59 by
doxygen 1.8.17 written
by
Dimitri van Heesch, © 1997-2006
KDE's Doxygen guidelines are available online.