ldforge2: comparison src/documentmanager.cpp

-:37f936073cac
+:e1ced2523cad
 */
 #include <QFile>
 #include <QDir>
 #include <QFileInfo>
+#include <QSaveFile>
 #include "documentmanager.h"
 #include "modeleditcontext.h"
 #include "linetypes/comment.h"
 #include "linetypes/subfilereference.h"
 #include "parser.h"
 {
 }
 /**
 * @brief Creates a new model.
-* @returns the name to the new model
+* @returns the ID of the new model
 */
-QString DocumentManager::newModel()
+ModelId DocumentManager::newModel()
 {
+	const ModelId modelId{++this->modelIdCounter};
 	const QString name = makeNewModelName();
-	this->openModels.emplace(name, new Model);
+	this->openModels[modelId] = ModelInfo{
-	return name;
+		.model = std::make_unique<Model>(),
+		.opentype = OpenType::ManuallyOpened,
+	};
+	return modelId;
 }
 /**
 * @brief Looks for a model by name
 * @param name Name of the model
 * @returns model or null
-* '
+*/
-*/
+Model* DocumentManager::findDependencyByName(const ModelId modelId, const QString& name)
-Model* DocumentManager::findModelByName(const QString& name)
+{
-{
+	const auto modelsIterator = this->openModels.find(modelId);
-	const auto iterator = this->openModels.find(name);
+	if (modelsIterator != std::end(this->openModels))
-	if (iterator == std::end(this->openModels))
+	{
+		const auto& dependencies = modelsIterator->second.dependencies;
+		const auto dependenciesIterator = dependencies.find(name);
+		if (dependenciesIterator != dependencies.end())
+		{
+			ModelInfo& modelInfo = this->openModels[dependenciesIterator->second];
+			return modelInfo.model.get();
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+	else
 	{
 		return nullptr;
 	}
-	else
+}
+/**
+* @brief Gets a model pointer by id or nullptr if not found
+* @param modelId id of model to find
+* @returns model pointer or null
+*/
+Model *DocumentManager::getModelById(ModelId modelId)
+{
+	const auto iterator = this->openModels.find(modelId);
+	if (iterator != this->openModels.end())
 	{
 		return iterator->second.model.get();
+	}
+	else
+	{
+		return nullptr;
 	}
 }
 QString pathToName(const QFileInfo& path)
 {
 /**
 * @brief Tries to open the model at the specified path
 * @param path Path to the model to open
 * @param errorStream Where to write any errors
 * @param openType rationale behind opening this file
-* @returns file name or "" on error
+* @returns model id, or no value on error
 */
-QString DocumentManager::openModel(const QString& path, QTextStream& errorStream, const OpenType openType)
+std::optional<ModelId> DocumentManager::openModel(
-{
+	const QString& path,
+	QTextStream& errorStream,
+	const OpenType openType
+) {
 	QFile file{path};
 	const QString name = pathToName(path);
 	file.open(QFile::ReadOnly | QFile::Text);
-	std::unique_ptr<Model> newModel = std::make_unique<Model>(path);
+	std::unique_ptr<Model> newModel = std::make_unique<Model>(this);
 	QTextStream textStream{&file};
 	Model::EditContext editor = newModel->edit();
 	Parser parser{file};
 	parser.parseBody(editor);
-	QString result;
+	std::optional<ModelId> result;
 	if (file.error() == QFile::NoError)
 	{
-		openModels[name] = {std::move(newModel), openType};
+		const ModelId modelId{++this->modelIdCounter};
-		result = name;
+		this->openModels[modelId] = {std::move(newModel), path, openType};
+		result = modelId;
 	}
 	else
 	{
 		errorStream << file.errorString();
 	}
 {
 	untitledNameCounter += 1;
 	return "untitled-" + QString::number(untitledNameCounter);
 }
+void DocumentManager::loadDependenciesForAllModels(const LibraryManager& libraries, QTextStream& errorStream)
+{
+	for (const auto& modelInfoPair : this->openModels)
+	{
+		this->loadDependenciesForModel(modelInfoPair.first, modelInfoPair.second.path, libraries, errorStream);
+	}
+}
+struct DocumentManager::LoadDepedenciesBag
+{
+	const LibraryManager& libraries;
+	QStringList missing;
+	QSet<ModelId> processed;
+	QTextStream& errorStream;
+};
 void DocumentManager::loadDependenciesForModel(
-	const QString& modelName,
+	const ModelId modelId,
 	const QString& path,
 	const LibraryManager& libraries,
 	QTextStream& errorStream)
 {
-	QStringList missing;
+	LoadDepedenciesBag bag {
-	QStringList processed;
+		.libraries = libraries,
-	loadDependenciesForModel(modelName, path, libraries, missing, processed, errorStream);
+		.missing = {},
-	if (not missing.empty())
+		.processed = {},
-	{
+		.errorStream = errorStream,
-		missing.sort(Qt::CaseInsensitive);
+	};
+	this->loadDependenciesForModel(modelId, path, bag);
+	if (not bag.missing.empty())
+	{
+		bag.missing.sort(Qt::CaseInsensitive);
 		errorStream << utility::format(
 			"The following files could not be opened: %1",
-			missing.join(", "));
+			bag.missing.join(", "));
 	}
 }
-void DocumentManager::closeDocument(const QString &name)
+void DocumentManager::closeDocument(const ModelId modelId)
 {
-	const auto& it = this->openModels.find(name);
+	ModelInfo* modelInfo = findInMap(this->openModels, modelId);
-	if (it != this->openModels.end())
+	if (modelInfo != nullptr)
 	{
-		this->openModels.erase(it);
+		modelInfo->opentype = OpenType::AutomaticallyOpened;
-	}
+		this->prune();
-	QSet<QString> referenced;
+	}
-	for (const auto& it : this->openModels)
+}
-	{
-		if (it.second.opentype == OpenType::ManuallyOpened)
+const QString *DocumentManager::modelPath(ModelId modelId) const
-		{
+{
-			this->collectReferences(referenced, it.first, it.second.model.get());
+	const auto iterator = this->openModels.find(modelId);
-		}
+	if (iterator != this->openModels.end())
-	}
+	{
+		return &iterator->second.path;
-}
+	}
+	else
-void DocumentManager::collectReferences(QSet<QString>& referenced, const QString &name, const Model *model)
+	{
-{
+		return nullptr;
-	if (not referenced.contains(name))
+	}
-	{
+}
-		referenced.insert(name);
-		model->apply<ldraw::SubfileReference>([&](const ldraw::SubfileReference* referenceObject)
+/**
-		{
+* @brief Changes the path of the specified model. Since the name of the file may change,
-			const ldraw::id_t id = referenceObject->id;
+* changing the path can cause dependencies to be resolved differently. As such, dependencies
-			const QString& referenceName = model->getObjectProperty<ldraw::Property::ReferenceName>(id);
+* need to be resolved for all files after this operation.
-			auto it = this->openModels.find(referenceName);
+* @param modelId Model to change the path of
-			if (it != this->openModels.end())
+* @param newPath New path
+* @param libraries Library manager for the purpose of dependency resolving
+* @param errorStream Where to write any errors regarding dependency resolving
+*/
+void DocumentManager::setModelPath(
+	const ModelId modelId,
+	const QString &newPath,
+	const LibraryManager &libraries,
+	QTextStream &errorStream)
+{
+	auto modelInfoPair = this->openModels.find(modelId);
+	if (true
+		and modelInfoPair != this->openModels.end()
+		and modelInfoPair->second.opentype == OpenType::ManuallyOpened
+	) {
+		modelInfoPair->second.path = newPath;
+		this->loadDependenciesForAllModels(libraries, errorStream);
+	}
+}
+bool DocumentManager::saveModel(const ModelId modelId, QTextStream &errors)
+{
+	const QString* const path = this->modelPath(modelId);
+	if (path != nullptr)
+	{
+		QSaveFile file{*path};
+		file.setDirectWriteFallback(true);
+		if (file.open(QSaveFile::WriteOnly))
+		{
+			// if path is not nullptr, getModelById will always return a value as well
+			this->getModelById(modelId)->save(&file);
+			const bool commitSucceeded = file.commit();
+			if (not commitSucceeded)
 			{
-				const Model* const model = it->second.model.get();
+				errors << tr("Could not save: %1").arg(file.errorString());
-				this->collectReferences(referenced, referenceName, model);
+				return false;
 			}
-		});
+			else
-	}
+			{
+				return true;
+			}
+		}
+		else
+		{
+			errors << tr("Could not open %1 for writing: %2")
+				.arg(file.fileName())
+				.arg(file.errorString());
+			return false;
+		}
+	}
+	else
+	{
+		errors << tr("Bad model ID %1").arg(modelId.value);
+		return false;
+	}
+}
+/**
+* @brief Searches the open models for the specified model and returns its id if found
+* @param model model to look for
+* @return id or no value if not found
+*/
+std::optional<ModelId> DocumentManager::findIdForModel(const Model *model) const
+{
+	std::optional<ModelId> result;
+	for (auto it = this->openModels.begin(); it != this->openModels.end(); ++it)
+	{
+		if (it->second.model.get() == model)
+		{
+			result = it->first;
+			break;
+		}
+	}
+	return result;
+}
+/**
+* @brief Cleans up and erases models that are no longer required.
+*/
+void DocumentManager::prune()
+{
+	for (auto it = this->openModels.begin(); it != this->openModels.end(); ++it)
+	{
+		// Find models that are not edited by the user and are not needed by any other model
+		if (true
+			and it->second.opentype == OpenType::AutomaticallyOpened
+			and not this->isReferencedByAnything(it->first)
+		) {
+			// Remove the model
+			this->openModels.erase(it);
+			// We need to start over now. It is possible that other models that previously
+			// were referenced by the model we just erased have become prunable.
+			// Moreover, our iterator is invalid now and we cannot continue in this for loop.
+			this->prune();
+			break;
+		}
+	}
+}
+/**
+* @brief Finds out whether the specified model id is referenced by any other model
+* @param modelId
+* @returns bool
+*/
+bool DocumentManager::isReferencedByAnything(const ModelId modelId) const
+{
+	for (auto& haystackModelPair : this->openModels)
+	{
+		if (haystackModelPair.first != modelId)
+		{
+			for (auto& dependencyPair : haystackModelPair.second.dependencies)
+			{
+				if (dependencyPair.second == modelId)
+				{
+					return true;
+				}
+			}
+		}
+	}
+	return false;
 }
 static QString findFile(QString referenceName, const QString& path, const LibraryManager& libraries)
 {
 	// Try to find the file in the same place as the model itself
 	}
 	return referencedFilePath;
 }
 void DocumentManager::loadDependenciesForModel(
-	const QString& modelName,
+	const ModelId modelId,
 	const QString &path,
-	const LibraryManager& libraries,
+	LoadDepedenciesBag& bag)
-	QStringList& missing,
+{
-	QStringList& processed,
+	QSet<QString> failedToOpen;
-	QTextStream& errorStream)
-{
 	struct LoadingError
 	{
 		QString message;
 	};
-	processed.append(modelName);
+	bag.processed.insert(modelId);
-	Model* model = this->findModelByName(modelName);
+	if (not this->openModels.contains(modelId))
-	for (int i = 0; i < model->size(); i += 1)
+	{
-	{
+		bag.errorStream << tr("bad model ID %1").arg(modelId.value);
-		const QString referenceName = model->getObjectProperty(i, ldraw::Property::ReferenceName).toString();
+		return;
+	}
+	ModelInfo& modelInfo = this->openModels[modelId];
+	modelInfo.dependencies.clear();
+	for (int i = 0; i < modelInfo.model->size(); i += 1)
+	{
+		const QString referenceName = modelInfo.model->getObjectProperty(i, ldraw::Property::ReferenceName).toString();
 		if (not referenceName.isEmpty()
-			and openModels.find(referenceName) == std::end(openModels)
+			and modelInfo.dependencies.count(referenceName) == 0
-			and not missing.contains(referenceName))
+			and not failedToOpen.contains(referenceName))
 		{
 			try
 			{
-				const QString referencedFilePath = findFile(referenceName, path, libraries);
+				const QString referencedFilePath = ::findFile(referenceName, path, bag.libraries);
 				if (referencedFilePath.isEmpty())
 				{
-					throw LoadingError{utility::format("'%1' was not found.", referenceName)};
+					throw LoadingError{tr("could not find '%1'").arg(referenceName)};
 				}
-				QString errorString;
+				QString loadErrorString;
-				QTextStream localErrorStream{&errorString};
+				QTextStream localErrorStream{&loadErrorString};
-				QString resultName = this->openModel(
+				const std::optional<ModelId> modelIdOpt = this->openModel(
 					referencedFilePath,
 					localErrorStream,
 					OpenType::AutomaticallyOpened);
-				if (resultName.isEmpty())
+				if (not modelIdOpt.has_value())
 				{
-					throw LoadingError{utility::format(
+					const QString& errorMessage = tr("could not load '%1': %2")
-						"could not load '%1': %2",
+						.arg(referencedFilePath)
-						referencedFilePath,
+						.arg(loadErrorString);
-						errorString)};
+					throw LoadingError{errorMessage};
 				}
-				if (not processed.contains(referenceName))
+				modelInfo.dependencies[referenceName] = modelIdOpt.value();
+				if (not bag.processed.contains(modelIdOpt.value()))
 				{
-					loadDependenciesForModel(referenceName, path, libraries, missing, processed, errorStream);
+					this->loadDependenciesForModel(modelIdOpt.value(), referencedFilePath, bag);
 				}
 			}
 			catch(const LoadingError& error)
 			{
-				errorStream << error.message << "\n";
+				bag.errorStream << error.message << "\n";
-				missing.append(referenceName);
+				failedToOpen.insert(referenceName);
-				processed.append(referenceName);
+				bag.missing.append(referenceName);
 			}
 		}
 	}
 }

Mercurial > ldforge2 / file comparison

comparison: src/documentmanager.cpp

src/documentmanager.cpp