src/model.h

/*
 *  LDForge: LDraw parts authoring CAD
 *  Copyright (C) 2013 - 2020 Teemu Piippo
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#include <QAbstractListModel>
#include <memory>
#include "main.h"
#include "header.h"
#include "linetypes/object.h"
#include "linetypes/metacommand.h"
#include "gl/common.h"

enum class HeaderProperty
{
	Name
};

class Model : public QAbstractListModel
{
	Q_OBJECT
public:
	Model(QObject* parent = nullptr);
	Model(const Model&) = delete;

	int size() const;
	ldraw::id_t at(int index) const;
	int rowCount(const QModelIndex&) const override;
	QVariant data(const QModelIndex& index, int role) const override;
	ldraw::Object* findObjectById(const ldraw::id_t id);
	const ldraw::Object* findObjectById(const ldraw::id_t id) const;
	QModelIndex find(ldraw::id_t id) const;
	ldraw::id_t idAt(const QModelIndex& index) const;
	template<typename R>
	const R* get(ldraw::Id<R> id) const;
	template<typename R>
	struct Get2Result
	{
		QModelIndex index;
		const R* object;
	};
	template<typename R>
	Get2Result<R> get2(ldraw::Id<R> id) const;
	ldraw::Object* operator[](int index);
	const ldraw::Object* operator[](int index) const;
	using ModelObjectPointer = std::unique_ptr<ldraw::Object>;
	template<typename T, typename... Args>
	ldraw::Id<T> append(Args&&... args);
	ldraw::id_t append(ModelObjectPointer&& object);
	template<typename T, typename... Args>
	ldraw::Id<T> insert(std::size_t position, Args&&... args);
	void remove(int position);
	void emitDataChangedSignal(int position);
private:
	bool modified = false;
	std::vector<ModelObjectPointer> body;
	mutable std::map<ldraw::id_t, std::size_t> objectsById;
	mutable bool needObjectsByIdRebuild = false;
};

void save(const Model& model, QIODevice *device);

/**
 * @brief Calls the specified function to all matching objects in the model
 * @tparam R Type of LDraw line type object to filter by
 * @param fn Function to call.
 */
template<typename R, typename Fn>
void applyToModel(const Model& model, Fn&& f)
{
	for (int i = 0; i < model.size(); i += 1)
	{
		const ldraw::Object* object = model[i];
		const R* subobject = dynamic_cast<const R*>(object);
		if (subobject != nullptr)
		{
			f(subobject);
		}
	}
}

template<typename T, typename... Args>
ldraw::Id<T> Model::append(Args&&... args)
{
	const int position = static_cast<int>(this->body.size());
	Q_EMIT beginInsertRows({}, position, position);
	this->body.push_back(std::make_unique<T>(args...));
	ldraw::Object* pointer = this->body.back().get();
	this->objectsById[pointer->id] = this->body.size() - 1;
	Q_EMIT endInsertRows();
	return ldraw::Id<T>{pointer->id.value};
}

template<typename T, typename... Args>
ldraw::Id<T> Model::insert(const std::size_t position, Args&&... args)
{
	Q_EMIT beginInsertRows({}, position, position);
	this->body.insert(std::begin(this->body) + position, std::make_unique<T>(args...));
	ldraw::Object* pointer = this->body[position].get();
	this->objectsById[pointer->id] = position;
	Q_EMIT endInsertRows();
	return ldraw::Id<T>{pointer->id.value};
}

template<typename R>
const R* Model::get(ldraw::Id<R> id) const
{
	return this->get2(id).object;
}

template<typename R>
Model::Get2Result<R> Model::get2(const ldraw::Id<R> id) const
{
	Get2Result<R> result;
	result.index = this->find(id);
	if (result.index.isValid())
	{
		result.object = static_cast<const R*>((*this)[result.index.row()]);
	}
	else
	{
		result.object = nullptr;
	}
	return result;
}