ldforge: comparison src/model.cpp

-:c2e0db52ea07
+:eae8b3bce545
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#include <cassert>
 #include "model.h"
 #include "linetypes/modelobject.h"
 #include "documentmanager.h"
 #include "linetypes/comment.h"
 #include "linetypes/conditionaledge.h"
 Model::Model(DocumentManager* manager) :
 QObject {manager},
 _manager {manager} {}
-Model::~Model()
-{
-	for (int i = 0; i < countof(_objects); ++i)
-		delete _objects[i];
-}
-/*
-* Takes an existing object and migrates it to the end of this model. The object is removed from its old model in the process.
-*/
-void Model::addObject(LDObject *object)
-{
-	insertObject(size(), object);
-}
 /*
 * Returns the amount of objects in this model.
 */
 int Model::size() const
 {
 }
 /*
 * Returns the vector of objects in this model.
 */
-const QVector<LDObject*>& Model::objects() const
+const ResourceVector<LDObject>& Model::objects() const
 {
 	return _objects;
 }
 /*
-* Takes an existing object and migrates it to this model, at the specified position.
+* Returns the vector of objects in this model (private mutable access)
 */
-void Model::insertObject(int position, LDObject* object)
+ResourceVector<LDObject>& Model::mutableObjects()
 {
-	if (object->model() and object->model() != this)
+	return _objects;
-		object->model()->withdraw(object);
+}
-	// TODO: check that the object isn't in the vector once there's a cheap way to do so!
+/*
-	_objects.insert(position, object);
+* Takes an existing object and adds it to this model, at the specified position.
+* The object is assumed to be ownerless.
+*/
+void Model::finalizeNewObject(int position, LDObject* object)
+{
+	assert(object->model() == this);
 	_needsTriangleRecount = true;
 	object->setDocument(this);
-	emit objectAdded(object);
-}
+	// Set default color. Relying on virtual functions, this cannot be done in the c-tor.
+	// TODO: store -1 as the default color
-/*
+	if (object->isColored())
-* Swaps one object with another, assuming they both are in this model.
+		object->setColor(object->defaultColor());
+	emit objectAdded(object, position);
+}
+/*
+* Swaps one object with another, if they both are in this model.
 */
 bool Model::swapObjects(LDObject* one, LDObject* other)
 {
 	int a = _objects.indexOf(one);
 	int b = _objects.indexOf(other);
 	if (a != b and a != -1 and b != -1)
 	{
-		_objects[b] = one;
+		_objects.swap(a, b);
-		_objects[a] = other;
+		emit objectsSwapped(one, other);
 		return true;
 	}
 	else
 	{
 		return false;
-	}
-}
-/*
-* Assigns a new object to the specified position in the model. The object that already is in the position is deleted in the process.
-*/
-bool Model::setObjectAt(int idx, LDObject* obj)
-{
-	if (idx < 0 or idx >= countof(_objects))
-	{
-		return false;
-	}
-	else
-	{
-		removeAt(idx);
-		insertObject(idx, obj);
-		return true;
 	}
 }
 /*
 * Returns the object at the specified position, or null if not found.
 /*
 * Removes the object at the provided position.
 */
 void Model::removeAt(int position)
 {
-	LDObject* object = withdrawAt(position);
+	emit aboutToRemoveObject(_objects[position], position);
-	delete object;
+	_objects.removeAt(position);
 }
 /*
 * Replaces the given object with the contents of a model.
 */
 void Model::replace(LDObject *object, Model &model)
 {
 	if (object->model() == this)
 	{
 		int position = object->lineNumber();
+		merge(model, position);
-		for (int i = countof(model.objects()) - 1; i >= 1; i -= 1)
+		remove(object);
-			insertObject(position + i, model.objects()[i]);
-		setObjectAt(position, model.objects()[0]);
 	}
 }
 /*
 * Signals the model to recount its triangles.
 	return _triangleCount;
 }
 /*
 * Merges the given model into this model, starting at the given position. The other model is emptied in the process.
-*/
+* If select is true, the new objects are added to the selection.
-void Model::merge(Model& other, int position)
+*/
+void Model::merge(Model& other, int position, Filter filter, Callback callback)
 {
 	if (position < 0)
 		position = countof(_objects);
-	// Copy the vector of objects to copy, so that we don't change the vector while iterating over it.
+	if (filter == nullptr)
-	QVector<LDObject*> objectsCopy = other._objects;
+		filter = [](LDObject*){return true;};
-	// Inform the contents of their new owner
+	_objects.merge(other.mutableObjects(), position, [&](LDObject* object, int objectPosition)
-	for (LDObject* object : objectsCopy)
+	{
-	{
+		if (filter(object))
-		insertObject(position, object);
+		{
-		position += 1;
+			emit other.aboutToRemoveObject(object, objectPosition);
-	}
+			return true;
+		}
-	other.clear();
+		else
+		{
+			return false;
+		}
+	}, [&](LDObject* object, int objectPosition)
+	{
+		_needsTriangleRecount = true;
+		object->setDocument(this);
+		emit objectAdded(object, objectPosition);
+		if (callback)
+			callback(object, position);
+	});
 }
 /*
 * Returns the begin-iterator into this model, so that models can be used in foreach-loops.
 */
-QVector<LDObject*>::iterator Model::begin()
+LDObject* const* Model::begin()
 {
 	return _objects.begin();
 }
 /*
 * Returns the end-iterator into this mode, so that models can be used in foreach-loops.
 */
-QVector<LDObject*>::iterator Model::end()
+LDObject* const* Model::end()
 {
 	return _objects.end();
 }
 /*
 	for (int i = _objects.size() - 1; i >= 0; i -= 1)
 		removeAt(i);
 	_triangleCount = 0;
 	_needsTriangleRecount = false;
-}
-/*
-* Drops the object from the model. The object becomes a free object as a result (thus violating the invariant that every object
-* has a model!). The caller must immediately add the withdrawn object to another model.
-*
-* This private method is only used to implement public API.
-*/
-void Model::withdraw(LDObject* object)
-{
-	if (object->model() == this)
-	{
-		int position = object->lineNumber();
-		if (_objects[position] == object)
-			withdrawAt(position);
-	}
-}
-/*
-* Drops an object from the model at the provided position. The caller must immediately put the result value object into a new model.
-*/
-LDObject* Model::withdrawAt(int position)
-{
-	LDObject* object = _objects[position];
-	emit aboutToRemoveObject(object);
-	_objects.removeAt(position);
-	_needsTriangleRecount = true;
-	return object;
 }
 /*
 * Returns whether or not this model is empty.
 */

Mercurial > ldforge / file comparison

comparison: src/model.cpp

src/model.cpp