ConvertDateToYMD(_date, &ymd);

	p1 = Clamp(p1, MIN_YEAR, MAX_YEAR);

	if (p1 == _cur_year) return _cur_year;

	Date new_date = ConvertYMDToDate(p1, ymd.month, ymd.day);

	SetDate(new_date, _date_fract);

	EnginesMonthlyLoop();

	SetWindowDirty(WC_STATUS_BAR, 0);

	InvalidateWindowClassesData(WC_BUILD_STATION, 0);

	InvalidateWindowClassesData(WC_BUILD_OBJECT, 0);

	ResetSignalVariant();

/* Initialize the link-graph-job-pool */

LinkGraphJobPool _link_graph_job_pool("LinkGraphJob");

INSTANTIATE_POOL_METHODS(LinkGraphJob)

/**

 * Create a link graph job from a link graph. The link graph will be copied so

 * that the calculations don't interfer with the normal operations on the

 * original. The job is immediately started.

 * @param orig Original LinkGraph to be copied.

 */

LinkGraphJob::LinkGraphJob(const LinkGraph &orig) :

/**

 * A leg of a path in the link graph. Paths can form trees by being "forked".

 */

class Path {

public:

	Path(NodeID n, bool source = false);

	/** Get the node this leg passes. */

	inline NodeID GetNode() const { return this->node; }

	/** Get the overall origin of the path. */

#include "mcf.h"

#include "flowmapper.h"

#include "../safeguards.h"

/**

 * Start the next job in the schedule.

 */

void LinkGraphSchedule::SpawnNext()

{

	if (this->schedule.empty()) return;

	LinkGraph *next = this->schedule.front();

 * ThreadObject::New.

 * @param j Pointer to a link graph job.

 */

/* static */ void LinkGraphSchedule::Run(void *j)

{

	LinkGraphJob *job = (LinkGraphJob *)j;

	}

}

/**

 * Start all threads in the running list. This is only useful for save/load.

 * Usually threads are started when the job is created.

/**

 * Clear all link graphs and jobs from the schedule.

 */

/* static */ void LinkGraphSchedule::Clear()

{

		(*i)->JoinThread();

	}

}

/**

 * 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 (uint i = 0; i < lengthof(this->handlers); ++i) {

		delete this->handlers[i];

	}

}

/**

 * Spawn or join a link graph job or compress a link graph if any link graph is

 * due to do so.

 */

void OnTick_LinkGraph()

{

	if (_date_fract != LinkGraphSchedule::SPAWN_JOIN_TICK) return;

	Date offset = _date % _settings_game.linkgraph.recalc_interval;

	if (offset == 0) {

	} else if (offset == _settings_game.linkgraph.recalc_interval / 2) {

	}

}

	GraphList schedule;            ///< Queue for new jobs.

	JobList running;               ///< Currently running jobs.

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 void Run(void *j);

	static void Clear();

	void SpawnNext();

	void JoinNext();

	void SpawnAll();

	 * Setup the node to retrieve edges from.

	 * @param source Root of the current path tree.

	 * @param node Current node to be checked for outgoing flows.

	 */

	void SetNode(NodeID source, NodeID node)

	{

		const FlowStatMap &flows = this->job[node].Flows();

		FlowStatMap::const_iterator it = flows.find(this->job[source].Station());

		if (it != flows.end()) {

			this->it = it->second.GetShares()->begin();

			this->end = it->second.GetShares()->end();

		} else {

		}

	}

	/**

	 * Get the next node for which a flow exists.

	 * @return ID of next node with flow.

 * @param origin_id Origin of the paths to be checked.

 * @param next_id Next node to be checked.

 * @return If any cycles have been found and eliminated.

 */

bool MCF1stPass::EliminateCycles(PathVector &path, NodeID origin_id, NodeID next_id)

{

	Path *at_next_pos = path[next_id];

	/* this node has already been searched */

	if (at_next_pos == NULL) {

		/* Summarize paths; add up the paths with the same source and next hop

		 * in one path each. */

		PathList &paths = this->job[next_id].Paths();

		PathViaMap next_hops;

		}

		/* All paths departing from this node have been searched. Mark as

		 * resolved if no cycles found. If cycles were found further cycles

		 * could be found in this branch, thus it has to be searched again next

		 * time we spot it.

		 */

		return found;

	}

	/* This node has already been visited => we have a cycle.

	 * Backtrack to find the exact flow. */

	uint flow = this->FindCycleFlow(path, at_next_pos);

/**

 * Load the link graph schedule.

 */

static void Load_LGRS()

{

}

/**

 * Spawn the threads for running link graph calculations.

 * Has to be done after loading as the cargo classes might have changed.

 */

			for (NodeID node_id = 0; node_id < lg->Size(); ++node_id) {

				(*lg)[node_id].UpdateLocation(Station::Get((*lg)[node_id].Station())->xy);

			}

		}

	}

}

/**

 * Save all link graphs.

 */

static void Save_LGRP()

/**

 * Save the link graph schedule.

 */

static void Save_LGRS()

{

}

/**

 * Substitute pointers in link graph schedule.

 */

static void Ptrs_LGRS()

{

}

extern const ChunkHandler _linkgraph_chunk_handlers[] = {

	{ 'LGRP', Save_LGRP, Load_LGRP, NULL,      NULL, CH_ARRAY },

	{ 'LGRJ', Save_LGRJ, Load_LGRJ, NULL,      NULL, CH_ARRAY },

	{ 'LGRS', Save_LGRS, Load_LGRS, Ptrs_LGRS, NULL, CH_LAST  }

				st->goods[c].flows.DeleteFlows(this->index);

				RerouteCargo(st, c, this->index, st->index);

			}

		}

		lg->RemoveNode(this->goods[c].node);

		if (lg->Size() == 0) {

			delete lg;

		}

	}

	Vehicle *v;

	FOR_ALL_VEHICLES(v) {

 * mean anything by itself.

 */

class FlowStat {

public:

	typedef std::map<uint32, StationID> SharesMap;

	/**

	 * Invalid constructor. This can't be called as a FlowStat must not be

	 * empty. However, the constructor must be defined and reachable for

	 * FlwoStat to be used in a std::map.

	 */

	inline FlowStat() {NOT_REACHED();}

#include "table/strings.h"

#include "safeguards.h"

/**

 * Check whether the given tile is a hangar.

 * @param t the tile to of whether it is a hangar.

 * @pre IsTileType(t, MP_STATION)

 * @return true if and only if the tile is a hangar.

 */

bool IsHangar(TileIndex t)

	GoodsEntry &ge2 = st2->goods[cargo];

	LinkGraph *lg = NULL;

	if (ge1.link_graph == INVALID_LINK_GRAPH) {

		if (ge2.link_graph == INVALID_LINK_GRAPH) {

			if (LinkGraph::CanAllocateItem()) {

				lg = new LinkGraph(cargo);

				ge2.link_graph = lg->index;

				ge2.node = lg->AddNode(st2);

			} else {

				DEBUG(misc, 0, "Can't allocate link graph");

			}

		} else {

		ge2.node = lg->AddNode(st2);

	} else {

		lg = LinkGraph::Get(ge1.link_graph);

		if (ge1.link_graph != ge2.link_graph) {

			LinkGraph *lg2 = LinkGraph::Get(ge2.link_graph);

			if (lg->Size() < lg2->Size()) {

				lg2->Merge(lg); // Updates GoodsEntries of lg

				lg = lg2;

			} else {

				lg->Merge(lg2); // Updates GoodsEntries of lg2

			}

		}

	}

	if (lg != NULL) {

		(*lg)[ge1.node].UpdateEdge(ge2.node, capacity, usage, mode);

	StationID next = ge.GetVia(st->index);

	ge.cargo.Append(new CargoPacket(st->index, st->xy, amount, source_type, source_id), next);

	LinkGraph *lg = NULL;

	if (ge.link_graph == INVALID_LINK_GRAPH) {

		if (LinkGraph::CanAllocateItem()) {

			lg = new LinkGraph(type);

			ge.link_graph = lg->index;

			ge.node = lg->AddNode(st);

		} else {

			DEBUG(misc, 0, "Can't allocate link graph");

		}

	} else {

 */

void SetStartingYear(Year year)

{

	_settings_game.game_creation.starting_year = Clamp(year, MIN_YEAR, MAX_YEAR);

	Date new_date = ConvertYMDToDate(_settings_game.game_creation.starting_year, 0, 1);

	/* If you open a savegame as scenario there may already be link graphs.*/

	SetDate(new_date, 0);

}

/**

 * Choose the proper callback function for the main toolbar's help menu.

 * @param index The menu index which was selected.