this->usage = 0;

	this->travel_time_sum = 0;

	this->last_unrestricted_update = INVALID_DATE;

	this->last_restricted_update = INVALID_DATE;

	this->dest_node = dest_node;

}

/**

 * Shift all dates by given interval.

 * This is useful if the date has been modified with the cheat menu.

 * @param interval Number of days to be added or subtracted.

 */

{

	this->last_compression += interval;

	for (NodeID node1 = 0; node1 < this->Size(); ++node1) {

		BaseNode &source = this->nodes[node1];

		if (source.last_update != INVALID_DATE) source.last_update += interval;

		for (BaseEdge &edge : this->nodes[node1].edges) {

			if (edge.last_unrestricted_update != INVALID_DATE) edge.last_unrestricted_update += interval;

			if (edge.last_restricted_update != INVALID_DATE) edge.last_restricted_update += interval;

		}

	}

}

		std::vector<BaseEdge>::const_iterator GetEdge(NodeID dest) const

		{

			return std::lower_bound(this->edges.begin(), this->edges.end(), dest);

		}

	};

	typedef std::vector<BaseNode> NodeVector;

	/** Minimum effective distance for timeout calculation. */

	static const uint MIN_TIMEOUT_DISTANCE = 32;

	/** Number of days before deleting links served only by vehicles stopped in depot. */

	/** Minimum number of days between subsequent compressions of a LG. */

	/**

	 * Scale a value from a link graph of age orig_age for usage in one of age

	 * target_age. Make sure that the value stays > 0 if it was > 0 before.

	 * @param val Value to be scaled.

	 * @param target_age Age of the target link graph.

	 * @param orig_age Age of the original link graph.

	 * @return scaled value.

	 */

	{

		return val > 0 ? std::max(1U, val * target_age / orig_age) : 0;

	}

	/** Bare constructor, only for save/load. */

	LinkGraph() : cargo(INVALID_CARGO), last_compression(0) {}

	/**

	 * Real constructor.

	 * @param cargo Cargo the link graph is about.

	 */

	LinkGraph(CargoID cargo) : cargo(cargo), last_compression(TimerGameCalendar::date) {}

	void Init(uint size);

	void Compress();

	void Merge(LinkGraph *other);

	/* Splitting link graphs is intentionally not implemented.

	 * The overhead in determining connectedness would probably outweigh the

	 * benefit of having to deal with smaller graphs. In real world examples

	 * networks generally grow. Only rarely a network is permanently split.

	 * Reacting to temporary splits here would obviously create performance

	 * problems and detecting the temporary or permanent nature of splits isn't

	 * trivial. */

	/**

	inline bool IsScheduledToBeJoined() const { return this->join_date <= TimerGameCalendar::date; }

	/**

	 * Get the date when the job should be finished.

	 * @return Join date.

	 */

	inline TimerGameCalendar::Date JoinDate() const { return join_date; }

	/**

	 * Change the join date on date cheating.

	 * @param interval Number of days to add.

	 */

	/**

	 * Get the link graph settings for this component.

	 * @return Settings.

	 */

	inline const LinkGraphSettings &Settings() const { return this->settings; }

	/**

	 * Get a node abstraction with the specified id.

	 * @param num ID of the node.

	 * @return the Requested node.

	 */

	for (auto &it : instance.running) {

		it->AbortJob();

	}

	instance.running.clear();

	instance.schedule.clear();

}

/**

 * Shift all dates (join dates and edge annotations) of link graphs and link

 * graph jobs by the number of days given.

 * @param interval Number of days to be added or subtracted.

 */

{

	for (LinkGraph *lg : LinkGraph::Iterate()) lg->ShiftDates(interval);

	for (LinkGraphJob *lgj : LinkGraphJob::Iterate()) lgj->ShiftJoinDate(interval);

}

/**

 * Create a link graph schedule and initialize its handlers.

 */

LinkGraphSchedule::LinkGraphSchedule()

{

	this->handlers[0] = new InitHandler;

	this->handlers[1] = new DemandHandler;

public:

	/* This is a tick where not much else is happening, so a small lag might go unnoticed. */

	static const uint SPAWN_JOIN_TICK = 21; ///< Tick when jobs are spawned or joined every day.

	static LinkGraphSchedule instance;

	static void Run(LinkGraphJob *job);

	static void Clear();

	void SpawnNext();

	bool IsJoinWithUnfinishedJobDue() const;

	void JoinNext();

	void SpawnAll();

	/**

	 * Queue a link graph for execution.

	 * @param lg Link graph to be queued.

	 */

	void Queue(LinkGraph *lg)

	{

		assert(LinkGraph::Get(lg->index) == lg);

		this->schedule.push_back(lg);

	}

	/**

void DeleteStaleLinks(Station *from)

{

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

		const bool auto_distributed = (_settings_game.linkgraph.GetDistributionType(c) != DT_MANUAL);

		GoodsEntry &ge = from->goods[c];

		LinkGraph *lg = LinkGraph::GetIfValid(ge.link_graph);

		if (lg == nullptr) continue;

		std::vector<NodeID> to_remove{};

		for (Edge &edge : (*lg)[ge.node].edges) {

			Station *to = Station::Get((*lg)[edge.dest_node].station);

			assert(to->goods[c].node == edge.dest_node);

			assert(TimerGameCalendar::date >= edge.LastUpdate());

				bool updated = false;

				if (auto_distributed) {

					/* Have all vehicles refresh their next hops before deciding to

					 * remove the node. */

					std::vector<Vehicle *> vehicles;

					for (OrderList *l : OrderList::Iterate()) {

						bool found_from = false;

						bool found_to = false;

						for (Order *order = l->GetFirstOrder(); order != nullptr; order = order->next) {

							if (!order->IsType(OT_GOTO_STATION) && !order->IsType(OT_IMPLICIT)) continue;

							if (order->GetDestination() == from->index) {

								found_to = true;

								if (found_from) break;

							}

						}

						if (!found_to || !found_from) continue;

						vehicles.push_back(l->GetFirstSharedVehicle());

					}

					auto iter = vehicles.begin();

					while (iter != vehicles.end()) {

						Vehicle *v = *iter;

						/* Do not refresh links of vehicles that have been stopped in depot for a long time. */

							LinkRefresher::Run(v, false); // Don't allow merging. Otherwise lg might get deleted.

						}

						if (edge.LastUpdate() == TimerGameCalendar::date) {

							updated = true;

							break;

						}

						Vehicle *next_shared = v->NextShared();

						if (next_shared) {

							*iter = next_shared;

							++iter;

						} else {

						}

						if (iter == vehicles.end()) iter = vehicles.begin();

					}

				}

				if (!updated) {

					/* If it's still considered dead remove it. */

					to_remove.emplace_back(to->goods[c].node);

					ge.flows.DeleteFlows(to->index);

					RerouteCargo(from, c, to->index, from->index);

				}

				edge.Restrict();

				ge.flows.RestrictFlows(to->index);

				RerouteCargo(from, c, to->index, from->index);

				edge.Release();

			}

		}

		/* Remove dead edges. */

		for (NodeID r : to_remove) (*lg)[ge.node].RemoveEdge(r);

		assert(TimerGameCalendar::date >= lg->LastCompression());

			lg->Compress();

		}

	}

}

/**

 * Increase capacity for a link stat given by station cargo and next hop.

 * @param st Station to get the link stats from.

 * @param cargo Cargo to increase stat for.

 * @param next_station_id Station the consist will be travelling to next.

 * @param capacity Capacity to add to link stat.

 * @param usage Usage to add to link stat.

 * @return GRF ID of the associated NewGRF.

 */

uint32_t Vehicle::GetGRFID() const

{

	return this->GetEngine()->GetGRFID();

}

/**

 * Shift all dates by given interval.

 * This is useful if the date has been modified with the cheat menu.

 * @param interval Number of days to be added or substracted.

 */

{

	this->date_of_last_service = std::max(this->date_of_last_service + interval, TimerGameCalendar::Date(0));

	/* date_of_last_service_newgrf is not updated here as it must stay stable

	 * for vehicles outside of a depot. */

}

/**

 * Handle the pathfinding result, especially the lost status.

 * If the vehicle is now lost and wasn't previously fire an

 * event to the AIs and a news message to the user. If the

 * vehicle is not lost anymore remove the news message.

 * @param path_found Whether the vehicle has a path to its destination.

	/**

	 * Calls the tick handler of the vehicle

	 * @return is this vehicle still valid?

	 */

	virtual bool Tick() { return true; };

	/**

	 * Calls the new day handler of the vehicle

	 */

	virtual void OnNewDay() {};

	/**

	 * Crash the (whole) vehicle chain.

	 * @param flooded whether the cause of the crash is flooding or not.

	 * @return the number of lost souls.

	 */

	virtual uint Crash(bool flooded = false);

	/**

	 * Returns the Trackdir on which the vehicle is currently located.

	 * Works for trains and ships.

	 * Currently works only sortof for road vehicles, since they have a fuzzy