/* Refresh next hop stats if we're full loading to make the links

			 * known to the distribution algorithm and allow cargo to be sent

			 * along them. Otherwise the vehicle could wait for cargo

			 * indefinitely if it hasn't visited the other links yet, or if the

			 * links die while it's loading. */

		}

		SB(front->vehicle_flags, VF_LOADING_FINISHED, 1, finished_loading);

	}

	/* Calculate the loading indicator fill percent and display

		this->edges[i][new_node].Init(distance);

	}

	return new_node;

}

/**

 * @param to Destination node of the link.

 * @param capacity Capacity of the link.

 */

{

	assert(this->index != to);

	BaseEdge &edge = this->edges[to];

	BaseEdge &first = this->edges[this->index];

	edge.capacity = capacity;

	edge.next_edge = first.next_edge;

	first.next_edge = to;

}

/**

 * Creates an edge if none exists yet or updates an existing edge.

 * @param to Target node.

 * @param capacity Capacity of the link.

 */

{

	assert(capacity > 0);

	if (this->edges[to].capacity == 0) {

	} else {

	}

}

/**

 * Remove an outgoing edge from this node.

 * @param to ID of destination node.

			next = this->edges[next].next_edge;

		}

	}

}

/**

 * @param from Start node of the edge.

 * @param to End node of the edge.

 * @param capacity Capacity to be added/updated.

 */

{

	assert(this->edge.capacity > 0);

		this->edge.capacity += capacity;

		this->edge.usage += usage;

	}

}

/**

 * Resize the component and fill it with empty nodes and edges. Used when

 * loading from save games. The component is expected to be empty before.

 * @param size New size of the component.

 * might change between the creation and join time so we can't rely on them.

 */

class LinkGraph : public LinkGraphPool::PoolItem<&_link_graph_pool> {

public:

	/**

	 * Node of the link graph. contains all relevant information from the associated

	 * station. It's copied so that the link graph job can work on its own data set

	 * in a separate thread.

	 */

	struct BaseNode {

		uint supply;             ///< Supply at the station.

	public:

		/**

		 * Constructor

		 * @param edge Edge to be wrapped.

		 */

		Edge(BaseEdge &edge) : EdgeWrapper<BaseEdge>(edge) {}

		void Restrict() { this->edge.last_unrestricted_update = INVALID_DATE; }

		void Release() { this->edge.last_restricted_update = INVALID_DATE; }

	};

	/**

	 * An iterator for const edges. Cannot be typedef'ed because of

		 */

		void SetDemand(uint demand)

		{

			this->node.demand = demand;

		}

		void RemoveEdge(NodeID to);

	};

	typedef SmallVector<BaseNode, 16> NodeVector;

	typedef SmallMatrix<BaseEdge> EdgeMatrix;

/* It needs to be 8bits, because we save and load it as such

 * Define basic enum properties

 */

template <> struct EnumPropsT<DistributionType> : MakeEnumPropsT<DistributionType, byte, DT_BEGIN, DT_END, DT_NUM> {};

typedef TinyEnumT<DistributionType> DistributionTypeByte; // typedefing-enumification of DistributionType

#endif /* LINKGRAPH_TYPE_H */

#include "../safeguards.h"

/**

 * Refresh all links the given vehicle will visit.

 * @param v Vehicle to refresh links for.

 * @param allow_merge If the refresher is allowed to merge or extend link graphs.

 */

{

	/* If there are no orders we can't predict anything.*/

	if (v->orders.list == NULL) return;

	/* Make sure the first order is a useful order. */

	const Order *first = v->orders.list->GetNextDecisionNode(v->GetOrder(v->cur_implicit_order_index), 0);

	if (first == NULL) return;

	HopSet seen_hops;

	refresher.RefreshLinks(first, first, v->last_loading_station != INVALID_STATION ? 1 << HAS_CARGO : 0);

}

/**

 * Comparison operator to allow hops to be used in a std::set.

/**

 * Constructor for link refreshing algorithm.

 * @param vehicle Vehicle to refresh links for.

 * @param seen_hops Set of hops already seen. This is shared between this

 *                  refresher and all its children.

 * @param allow_merge If the refresher is allowed to merge or extend link graphs.

 */

{

	/* Assemble list of capacities and set last loading stations to 0. */

	for (Vehicle *v = this->vehicle; v != NULL; v = v->Next()) {

		this->refit_capacities.push_back(RefitDesc(v->cargo_type, v->cargo_cap, v->refit_cap));

		if (v->refit_cap > 0) this->capacities[v->cargo_type] += v->refit_cap;

	}

			/* If not allowed to merge link graphs, make sure the stations are

			 * already in the same link graph. */

			if (!this->allow_merge && st->goods[c].link_graph != Station::Get(next_station)->goods[c].link_graph) {

				continue;

			}

		}

	}

}

/**

 * Iterate over orders starting at \a cur and \a next and refresh links

/**

 * Utility to refresh links a consist will visit.

 */

class LinkRefresher {

public:

protected:

	/**

	 * Various flags about properties of the last examined link that might have

	 * an influence on the next one.

	 */

	Vehicle *vehicle;           ///< Vehicle for which the links should be refreshed.

	CapacitiesMap capacities;   ///< Current added capacities per cargo ID in the consist.

	RefitList refit_capacities; ///< Current state of capacity remaining from previous refits versus overall capacity per vehicle in the consist.

	HopSet *seen_hops;          ///< Hops already seen. If the same hop is seen twice we stop the algorithm. This is shared between all Refreshers of the same run.

	CargoID cargo;              ///< Cargo given in last refit order.

	bool allow_merge;           ///< If the refresher is allowed to merge or extend link graphs.

	void HandleRefit(const Order *next);

	void ResetRefit();

	void RefreshStats(const Order *cur, const Order *next);

	const Order *PredictNextOrder(const Order *cur, const Order *next, uint8 flags, uint num_hops = 0);

/**

 * 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.

 */

{

	GoodsEntry &ge1 = st->goods[cargo];

	Station *st2 = Station::Get(next_station_id);

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

	LinkGraph *lg = NULL;

	if (ge1.link_graph == INVALID_LINK_GRAPH) {

				LinkGraphSchedule::Instance()->Unqueue(lg2);

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

			}

		}

	}

	if (lg != NULL) {

	}

}

/**

 * Increase capacity for all link stats associated with vehicles in the given consist.

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

			 * wagons have been auto-replaced and subsequently auto-

			 * refitted to a higher capacity. The cargo gets redistributed

			 * among the wagons in that case.

			 * As usage is not such an important figure anyway we just

			 * ignore the additional cargo then.*/

			IncreaseStats(st, v->cargo_type, next_station_id, v->refit_cap,

		}

	}

}

/* called for every station each tick */

static void StationHandleSmallTick(BaseStation *st)

#include "sprite.h"

#include "rail_type.h"

#include "road_type.h"

#include "vehicle_type.h"

#include "economy_func.h"

#include "rail.h"

void ModifyStationRatingAround(TileIndex tile, Owner owner, int amount, uint radius);

void FindStationsAroundTiles(const TileArea &location, StationList *stations);

void ShowStationViewWindow(StationID station);

void UpdateAirportsNoise();

bool SplitGroundSpriteForOverlay(const TileInfo *ti, SpriteID *ground, RailTrackOffset *overlay_offset);

void IncreaseStats(Station *st, const Vehicle *v, StationID next_station_id);

void RerouteCargo(Station *st, CargoID c, StationID avoid, StationID avoid2);

/**

 * Calculates the maintenance cost of a number of station tiles.

 * @param num Number of station tiles.

 * @return Total cost.