flatitemsmodeltypedbase.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#pragma once
 
#include <source_location>
#include "flatitemsmodelbase.h"
#include "modelsanitizer.h"
 
namespace LC::Util
{
    template<typename T>
    class FlatItemsModelTypedBase : public FlatItemsModelBase
    {
    protected:
        QList<T> Items_;
    public:
        explicit FlatItemsModelTypedBase (QStringList headers, QObject *parent = nullptr)
        : FlatItemsModelBase { std::move (headers), parent }
        {
            InstallModelSanitizer (*this);
        }
 
        void SetItems (QList<T> items)
        {
            beginResetModel ();
            Items_ = std::move (items);
            endResetModel ();
        }
 
        template<typename U>
            requires std::is_constructible_v<T, U&&>
        void SetItems (QList<U> items)
        {
            beginResetModel ();
            Items_.clear ();
            Items_.reserve (items.size ());
            for (auto&& item : items)
                Items_ << T { std::move (item) };
            endResetModel ();
        }
 
        const QList<T>& GetItems () const
        {
            return Items_;
        }
 
        QList<T>& GetMutItems ()
        {
            return Items_;
        }
 
        qsizetype AddItem (const T& item)
        {
            const auto pos = Items_.size ();
 
            beginInsertRows ({}, Items_.size (), Items_.size ());
            Items_.push_back (item);
            endInsertRows ();
 
            return pos;
        }
 
        void AddItems (const QList<T>& items)
        {
            if (items.isEmpty ())
                return;
 
            beginInsertRows ({}, Items_.size (), Items_.size () + items.size () - 1);
            Items_ += items;
            endInsertRows ();
        }
 
        void SetItem (int idx, const T& item)
        {
            ItemAt (idx) = item;
            emit dataChanged (index (idx, 0),
                    index (idx, columnCount ({}) - 1));
        }
 
        template<typename F>
        void EditItem (int idx, F&& editor)
        {
            std::invoke (std::forward<F> (editor), ItemAt (idx));
            emit dataChanged (index (idx, 0),
                    index (idx, columnCount ({}) - 1));
        }
 
        void RemoveItem (int idx)
        {
            CheckRow (idx, std::source_location::current ());
            beginRemoveRows ({}, idx, idx);
            Items_.removeAt (idx);
            endRemoveRows ();
        }
 
        void RemoveItem (QList<T>::const_iterator it)
        {
            RemoveItem (it - Items_.begin ());
        }
    protected:
        int GetItemsCount () const override
        {
            return Items_.size ();
        }
 
        auto& ItemAt (this auto&& self, int row, const std::source_location& loc = std::source_location::current ())
        {
            self.CheckRow (row, loc);
            return self.Items_ [row];
        }
    private:
        void CheckRow (int row, const std::source_location& loc) const
        {
            if (row < 0 || row >= Items_.size ())
                NotifyRowOutOfRange (*this, row, Items_.size (), loc);
        }
    };
}