queryresults.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Manuel Schneider
// SPDX-License-Identifier: MIT
 
#pragma once
#include <QObject>
#include <albert/export.h>
#include <albert/item.h>
#include <albert/querycontext.h>
#include <memory>
#include <ranges>
#include <vector>
 
namespace albert
{
class Extension;
 
class ALBERT_EXPORT QueryResult
{
public:
    const Extension *extension; 
    std::shared_ptr<Item> item; 
};
 
class ALBERT_EXPORT QueryResults : public QObject, private Item::Observer
{
    Q_OBJECT
 
public:
 
    QueryResults(const QueryContext &context);
 
    ~QueryResults() override;
 
    inline QueryResult &operator[](size_t index) { return results[index]; }
 
    inline const QueryResult &operator[](size_t index) const { return results[index]; }
 
    inline uint count() const { return results.size(); }
 
    bool activate(uint item_index, uint action_index = 0);
 
    void add(const Extension &extension, ItemPtr auto &&item)
    {
        emit resultsAboutToBeInserted(results.size(), results.size());
        item->addObserver(this);
        results.emplace_back(&extension, std::forward<decltype(item)>(item));
        emit resultsInserted();
    }
 
    void add(ItemPtr auto &&item) { add(context.handler(), std::forward<decltype(item)>(item)); }
 
    void add(std::ranges::range auto &&query_results)
        requires(std::same_as<QueryResult, std::ranges::range_value_t<decltype(query_results)>>)
    {
        if (!query_results.empty())
        {
            const auto count = std::ranges::distance(query_results);
            results.reserve(results.size() + count);
            emit resultsAboutToBeInserted(results.size(), results.size() + count - 1);
            for (auto&& query_result : query_results)
            {
                query_result.item->addObserver(this);
                // results.emplace_back(std::forward_like<decltype(query_results)>(query_result));
                // TODO remove if forward_like is available everywhere (26.04)
                if constexpr (std::is_lvalue_reference_v<decltype(query_results)>)
                    results.emplace_back(query_result);
                else
                    results.emplace_back(std::move(query_result));
            }
            emit resultsInserted();
        }
    }
 
    void add(const Extension &extension, ItemRange auto &&items)
    {
        if (!items.empty())
        {
            const auto count = std::ranges::distance(items);
            results.reserve(results.size() + count);
            emit resultsAboutToBeInserted(results.size(), results.size() + count - 1);
            for (auto&& item : items)
            {
                item->addObserver(this);
                // results.emplace_back(std::forward_like<decltype(query_results)>(query_result));
                // TODO remove if forward_like is available everywhere (26.04)
                if constexpr (std::is_lvalue_reference_v<decltype(items)>)
                    results.emplace_back(&extension, item);
                else
                    results.emplace_back(&extension, std::move(item));
            }
            emit resultsInserted();
        }
    }
 
    void add(ItemRange auto &&items){ add(context.handler(), std::forward<decltype(items)>(items)); }
 
    void remove(uint index, uint count = 1)
    {
        for (auto i = index; i < index + count; ++i)
            results[i].item->removeObserver(this);
 
        emit resultsAboutToBeRemoved(index, index + count - 1);
        results.erase(results.begin() + index,results.begin() + index + count);
        emit resultsRemoved();
 
    }
 
    void reset()
    {
        for (auto&& result : results)
            result.item->removeObserver(this);
        emit resultsAboutToBeReset();
        results.clear();
        emit resultsReset();
    }
 
signals:
 
    void resultsAboutToBeInserted(int first, int last);
 
    void resultsInserted();
 
    void resultsAboutToBeRemoved(int first, int last);
 
    void resultsRemoved();
 
    void resultsAboutToBeMoved(int srcFirst, int srcLast, int dst);
 
    void resultsMoved();
 
    void resultsAboutToBeReset();
 
    void resultsReset();
 
    void resultChanged(uint i);
 
    void resultActivated(QString query, QString extension_id, QString item_id, QString action_id);
 
private:
 
    void notify(const albert::Item *item) override;
 
    const QueryContext &context;
    std::vector<QueryResult> results;
 
};
 
}