(svn r14085) -Cleanup (r14083): Remove no longer used functions.

1 files changed, 0 insertions, 152 deletions

diff --git a/src/vehicle.cpp b/src/vehicle.cpp
index 79e72e71a..bd64a4d69 100644
--- a/src/vehicle.cpp
+++ b/src/vehicle.cpp
@@ -2578,158 +2578,6 @@ void Vehicle::SetNext(Vehicle *next)
 	}
 }
 
-/** Backs up a chain of vehicles
- * @param v The vehicle to back up
- */
-void BackuppedVehicle::BackupVehicle(Vehicle *v)
-{
-	int length = CountVehiclesInChain(v);
-
-	size_t cargo_packages_count = 1;
-	for (const Vehicle *v_count = v; v_count != NULL; v_count=v_count->Next()) {
-		/* Now we count how many cargo packets we need to store.
-		 * We started with an offset by one because we also need an end of array marker. */
-		cargo_packages_count += v_count->cargo.packets.size();
-	}
-
-	vehicles = MallocT<Vehicle>(length);
-	cargo_packets = MallocT<CargoPacket>(cargo_packages_count);
-
-	/* Now we make some pointers to iterate over the arrays. */
-	Vehicle *copy = vehicles;
-	CargoPacket *cargo = cargo_packets;
-
-	Vehicle *original = v;
-
-	for (; 0 < length; original = original->Next(), copy++, length--) {
-		/* First we need to copy the vehicle itself.
-		 * However there is an issue as the cargo list isn't copied.
-		 * To avoid restoring invalid pointers we start by swapping the cargo list with an empty one. */
-		CargoList::List empty_packets;
-		original->cargo.packets.swap(empty_packets);
-		memcpy(copy, original, sizeof(Vehicle));
-
-		/* No need to do anything else if the cargo list is empty.
-		 * It really doesn't matter if we swap an empty list with an empty list. */
-		if (original->cargo.Empty()) continue;
-
-		/* And now we swap the cargo lists back. The vehicle now has it's cargo again. */
-		original->cargo.packets.swap(empty_packets);
-
-		/* The vehicle contains some cargo so we will back up the cargo as well.
-		 * We only need to store the packets and not which vehicle they came from.
-		 * We will still be able to put them together with the right vehicle when restoring. */
-		const CargoList::List *packets = original->cargo.Packets();
-		for (CargoList::List::const_iterator it = packets->begin(); it != packets->end(); it++) {
-			memcpy(cargo, (*it), sizeof(CargoPacket));
-			cargo++;
-		}
-	}
-	/* We should end with a 0 packet so restoring can detect the end of the array. */
-	memset(cargo, 0, sizeof(CargoPacket));
-}
-
-/** Restore a backed up row of vehicles
- * @param *v The array of vehicles to restore
- * @param *p The owner of the vehicle
- */
-Vehicle* BackuppedVehicle::RestoreBackupVehicle(Vehicle *v, Player *p)
-{
-	Vehicle *backup = v;
-	CargoPacket *cargo = cargo_packets;
-
-	assert(v->owner == p->index);
-
-	/* Cache the result of the vehicle type check since it will not change
-	 * and we need this check once for every run though the loop. */
-	bool is_road_veh = v->type == VEH_ROAD;
-
-	while (true) {
-		Vehicle *dest = GetVehicle(backup->index);
-		/* The vehicle should be free since we are restoring something we just sold. */
-		assert(!dest->IsValid());
-		memcpy(dest, backup, sizeof(Vehicle));
-
-		/* We decreased the engine count when we sold the engines so we will increase it again. */
-		if (IsEngineCountable(backup)) {
-			p->num_engines[backup->engine_type]++;
-			if (IsValidGroupID(backup->group_id)) GetGroup(backup->group_id)->num_engines[backup->engine_type]++;
-			if (backup->IsPrimaryVehicle()) IncreaseGroupNumVehicle(backup->group_id);
-		}
-
-		/* Update hash. */
-		Vehicle *dummy = dest;
-		dest->old_new_hash = &dummy;
-		dest->left_coord = INVALID_COORD;
-		UpdateVehiclePosHash(dest, INVALID_COORD, 0);
-
-		if (is_road_veh) {
-			/* Removed the slot in the road vehicles as the slot is gone.
-			 * We don't want a pointer to a slot that's gone.              */
-			dest->u.road.slot = NULL;
-		}
-
-		if (!dest->cargo.Empty()) {
-			/* The vehicle in question contains some cargo.
-			 * However we lost the list so we will have to recreate it.
-			 * We know that the packets are stored in the same order as the vehicles so
-			 * the one cargo_packets points to and maybe some following ones belongs to
-			 * the current vehicle.
-			 * Now all we have to do is to add the packets to a list and keep track of how
-			 * much cargo we restore and once we reached the cached cargo hold we recovered
-			 * everything for this vehicle. */
-			uint cargo_count = 0;
-			for(; cargo_count < dest->cargo.Count(); cargo++) {
-				dest->cargo.packets.push_back(GetCargoPacket(cargo->index));
-				cargo_count += cargo->count;
-			}
-			/* This design should always end up with the right amount of cargo. */
-			assert(cargo_count == dest->cargo.Count());
-		}
-
-		if (backup->Next() == NULL) break;
-		backup++;
-	}
-	return GetVehicle(v->index);
-}
-
-/** Restores a backed up vehicle
- * @param *v A vehicle we should sell and take the windows from (NULL for not using this)
- * @param *p The owner of the vehicle
- * @return The vehicle we restored (front for trains) or v if we didn't have anything to restore
- */
-Vehicle *BackuppedVehicle::Restore(Vehicle *v, Player *p)
-{
-	if (!ContainsBackup()) return v;
-	if (v != NULL) {
-		ChangeVehicleViewWindow(v->index, INVALID_VEHICLE);
-		DoCommand(0, v->index, 1, DC_EXEC, GetCmdSellVeh(v));
-	}
-	v = RestoreBackupVehicle(this->vehicles, p);
-	ChangeVehicleViewWindow(INVALID_VEHICLE, v->index);
-	if (orders != NULL) RestoreVehicleOrdersBruteForce(v, orders);
-	if (economy != NULL) economy->Restore();
-	/* If we stored cargo as well then we should restore it. */
-	cargo_packets->RestoreBackup();
-	return v;
-}
-
-/** Backs up a vehicle
- * This should never be called when the object already contains a backup
- * @param v the vehicle to backup
- * @param p If it's set to the vehicle's owner then economy is backed up. If NULL then economy backup will be skipped.
- */
-void BackuppedVehicle::Backup(Vehicle *v, Player *p)
-{
-	assert(!ContainsBackup());
-	if (p != NULL) {
-		assert(p->index == v->owner);
-		economy = new PlayerMoneyBackup(p);
-	}
-	BackupVehicle(v);
-	if (orders != NULL) BackupVehicleOrders(v, orders);
-}
-
 void StopAllVehicles()
 {
 	Vehicle *v;