/**

 * Clean up a depot

 */

Depot::~Depot()

{

	/* Clear the depot from all order-lists */

	RemoveOrderFromAllVehicles(OT_GOTO_DEPOT, this->index);

	/* Delete the depot-window */

	DeleteWindowById(WC_VEHICLE_DEPOT, this->xy);

	this->xy = 0;

	bool replace_protection;                ///< If set to true, the global autoreplace have no effect on the group

	uint16 num_engines[TOTAL_NUM_ENGINES];  ///< Caches the number of engines of each type the player owns (no need to save this)

	Group(StringID str = STR_NULL);

	virtual ~Group();

	bool IsValid() const;

};

static inline bool IsValidGroupID(GroupID index)

{

{

	this->string_id = str;

}

Group::~Group()

{

	this->string_id = STR_NULL;

}

bool Group::IsValid() const

{

	return this->string_id != STR_NULL;

}

void InitializeGroup(void)

void OldMemoryPoolBase::CleanPool()

{

	uint i;

	DEBUG(misc, 4, "[Pool] (%s) cleaning pool..", this->name);

	/* Free all blocks */

	for (i = 0; i < this->current_blocks; i++) {

		if (this->clean_block_proc != NULL) {

			this->clean_block_proc(i * (1 << this->block_size_bits), (i + 1) * (1 << this->block_size_bits) - 1);

		}

		free(this->blocks[i]);

	}

	/* Free the block itself */

	free(this->blocks);

	/* Clear up some critical data */

	this->total_items = 0;

protected:

	OldMemoryPoolBase(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

		name(name), max_blocks(max_blocks), block_size_bits(block_size_bits),

		new_block_proc(new_block_proc), clean_block_proc(clean_block_proc), current_blocks(0),

	const char* name;     ///< Name of the pool (just for debugging)

	const uint max_blocks;      ///< The max amount of blocks this pool can have

	const uint block_size_bits; ///< The size of each block in bits

	/// Pointer to a function that is called to clean a block

	OldMemoryPoolCleanBlock *clean_block_proc;

	uint current_blocks;        ///< How many blocks we have in our pool

	uint total_items;           ///< How many items we now have in this pool

public:

	const uint item_size;       ///< How many bytes one block is

	uint first_free_index;      ///< The index of the first free pool item in this pool

	byte **blocks;              ///< An array of blocks (one block hold all the items)

	/**

	 * @return the name

	 */

	inline const char *GetName() const

	{

		return this->name;

	}

};

template <typename T>

struct OldMemoryPool : public OldMemoryPoolBase {

	OldMemoryPool(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

		t->index = start_item++;

	}

}

/**

 * Generic function to free a new block in a pool.

 * @param start_item the first item that needs to be cleaned

 * @param end_item   the last item that needs to be cleaned

 */

template <typename T, OldMemoryPool<T> *Tpool>

static void PoolCleanBlock(uint start_item, uint end_item)

{

	for (uint i = start_item; i <= end_item; i++) {

		T *t = Tpool->Get(i);

	}

}

/**

 * Generalization for all pool items that are saved in the savegame.

	virtual ~PoolItem()

	{

		if (this->index < Tpool->first_free_index) Tpool->first_free_index = this->index;

	}

	/**

	 * An overriden version of new that allocates memory on the pool.

	 * @param size the size of the variable (unused)

	 * @return the memory that is 'allocated'

	 */

	void *operator new(size_t size)

	{

protected:

	/**

	 * Allocate a pool item; possibly allocate a new block in the pool.

	 * @return the allocated pool item (or NULL when the pool is full).

	 */

	{

		return AllocateRaw(Tpool->first_free_index);

	}

	/**

	 * Allocate a pool item; possibly allocate a new block in the pool.

	 * @param first the first pool item to start searching

	 * @return the allocated pool item (or NULL when the pool is full).

	 */

	{

		uint last_minus_one = Tpool->GetSize() - 1;

		for (T *t = Tpool->Get(first); t != NULL; t = (t->index < last_minus_one) ? Tpool->Get(t->index + 1U) : NULL) {

			if (!t->IsValid()) {

				first = t->index;

		/* Check if we can add a block to the pool */

		if (Tpool->AddBlockToPool()) return AllocateRaw(first);

		return NULL;

	}

};

#define OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

	enum { \

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

{

	this->str = string;

}

Sign::~Sign()

{

	this->str = STR_NULL;

}

/**

 *

 * Update the coordinate of one sign

 * @param si Pointer to the Sign

 *

 */

	Sign(StringID string = STR_NULL);

	/** Destroy the sign */

	~Sign();

	bool IsValid() const { return this->str != STR_NULL; }

};

enum {

	INVALID_SIGN = 0xFFFF,

};

 * is OT_GOTO_DEPOT.

 */

Station::~Station()

{

	DEBUG(station, cDebugCtorLevel, "I-%3d", index);

	MarkDirty();

	RebuildStationLists();

	InvalidateWindowClasses(WC_STATION_LIST);

	DeleteWindowById(WC_STATION_VIEW, index);

	xy = 0;

	for (CargoID c = 0; c < NUM_CARGO; c++) {

		goods[c].cargo.Truncate(0);

	}

}

/** Called when new facility is built on the station. If it is the first facility

 * it initializes also 'xy' and 'random_bits' members */

void Station::AddFacility(byte new_facility_bit, TileIndex facil_xy)

{

	static const int cDebugCtorLevel = 5;

	Station(TileIndex tile = 0);

	virtual ~Station();

	void AddFacility(byte new_facility_bit, TileIndex facil_xy);

	void MarkDirty() const;

	void MarkTilesDirty(bool cargo_change) const;

	bool TileBelongsToRailStation(TileIndex tile) const;

	uint GetPlatformLength(TileIndex tile, DiagDirection dir) const;

	uint GetPlatformLength(TileIndex tile) const;

	Town(TileIndex tile = 0);

	/** Destroy the town */

	~Town();

	bool IsValid() const { return this->xy != 0; }

};

struct HouseSpec {

	/* Standard properties */

	Year min_date;                     ///< introduction year of the house

	Year max_date;                     ///< last year it can be built

	if (tile != 0) _total_towns++;

	this->xy = tile;

}

Town::~Town()

{

	Industry *i;

	/* Delete town authority window

	 * and remove from list of sorted towns */

	DeleteWindowById(WC_TOWN_VIEW, this->index);

	_town_sort_dirty = true;

	}

	DeleteSubsidyWithTown(this->index);

	MarkWholeScreenDirty();

	this->xy = 0;

}

// Local

static int _grow_town_result;

static bool BuildTownHouse(Town *t, TileIndex tile);

static void DoBuildTownHouse(Town *t, TileIndex tile);

		default: return false; // Only count player buildable vehicles

	}

}

void Vehicle::PreDestructor()

{

	if (IsValidStationID(this->last_station_visited)) {

		GetStation(this->last_station_visited)->loading_vehicles.remove(this);

		HideFillingPercent(this->fill_percent_te_id);

		this->fill_percent_te_id = INVALID_TE_ID;

	}

		if (this->owner == _local_player) InvalidateAutoreplaceWindow(this->engine_type, this->group_id);

		if (IsValidGroupID(this->group_id)) GetGroup(this->group_id)->num_engines[this->engine_type]--;

		if (this->IsPrimaryVehicle()) DecreaseGroupNumVehicle(this->group_id);

	}

	if (this->type == VEH_ROAD) ClearSlot(this);

	if (this->type != VEH_TRAIN || (this->type == VEH_TRAIN && (IsFrontEngine(this) || IsFreeWagon(this)))) {

		InvalidateWindowData(WC_VEHICLE_DEPOT, this->tile);

	}

		delete this->next;

	}

}

Vehicle::~Vehicle()

{

	UpdateVehiclePosHash(this, INVALID_COORD, 0);

	this->next_hash = NULL;

	this->next_new_hash = NULL;

	DeleteVehicleNews(this->index, INVALID_STRING_ID);

	new (this) InvalidVehicle();

}

/**

 * Deletes all vehicles in a chain.

 * @param v The first vehicle in the chain.

 *

 * @warning This function is not valid for any vehicle containing articulated

 * parts.

	/** Destroy all stuff that (still) needs the virtual functions to work properly */

	void PreDestructor();

	/** We want to 'destruct' the right class. */

	virtual ~Vehicle();

	void BeginLoading();

	void LeaveStation();

	/**

	 * Handle the loading of the vehicle; when not it skips through dummy

	 * orders and does nothing in all other cases.

{

	this->xy = tile;

}

Waypoint::~Waypoint()

{

	RemoveOrderFromAllVehicles(OT_GOTO_WAYPOINT, this->index);

	RedrawWaypointSign(this);

	this->xy = 0;

}

bool Waypoint::IsValid() const

{

	return this->xy != 0;

}

	byte deleted;      ///< Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is deleted.

	Waypoint(TileIndex tile = 0);

	~Waypoint();

	bool IsValid() const;

};

static inline bool IsValidWaypointID(WaypointID index)

{

	return index < GetWaypointPoolSize() && GetWaypoint(index)->IsValid();