<ClCompile Include="..\src\saveload\linkgraph_sl.cpp" />

    <ClCompile Include="..\src\saveload\linkgraph_sl.cpp">

      <Filter>Save/Load handlers</Filter>

    </ClCompile>

				RelativePath=".\..\src\saveload\linkgraph_sl.cpp"

				>

			</File>

			<File

				RelativePath=".\..\src\saveload\linkgraph_sl.cpp"

				>

			</File>

			<File

saveload/linkgraph_sl.cpp

/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

/** @file linkgraph_sl.cpp Code handling saving and loading of link graphs */

#include "../stdafx.h"

#include "../linkgraph/linkgraph.h"

#include "../settings_internal.h"

#include "saveload.h"

typedef LinkGraph::BaseNode Node;

typedef LinkGraph::BaseEdge Edge;

static uint _num_nodes;

/**

 * Get a SaveLoad array for a link graph.

 * @return SaveLoad array for link graph.

 */

const SaveLoad *GetLinkGraphDesc()

{

	static const SaveLoad link_graph_desc[] = {

		 SLE_VAR(LinkGraph, last_compression, SLE_UINT32),

		SLEG_VAR(_num_nodes,                  SLE_UINT16),

		 SLE_VAR(LinkGraph, cargo,            SLE_UINT8),

		 SLE_END()

	};

	return link_graph_desc;

}

/* Edges and nodes are saved in the correct order, so we don't need to save their IDs. */

/**

 * SaveLoad desc for a link graph node.

 */

static const SaveLoad _node_desc[] = {

	SLE_VAR(Node, supply,      SLE_UINT32),

	SLE_VAR(Node, demand,      SLE_UINT32),

	SLE_VAR(Node, station,     SLE_UINT16),

	SLE_VAR(Node, last_update, SLE_UINT32),

	SLE_END()

};

/**

 * SaveLoad desc for a link graph edge.

 */

static const SaveLoad _edge_desc[] = {

	SLE_VAR(Edge, distance,    SLE_UINT32),

	SLE_VAR(Edge, capacity,    SLE_UINT32),

	SLE_VAR(Edge, usage,       SLE_UINT32),

	SLE_VAR(Edge, last_update, SLE_UINT32),

	SLE_VAR(Edge, next_edge,   SLE_UINT16),

	SLE_END()

};

/**

 * Save/load a link graph.

 * @param comp Link graph to be saved or loaded.

 */

void SaveLoad_LinkGraph(LinkGraph &lg)

{

	uint size = lg.Size();

	for (NodeID from = 0; from < size; ++from) {

		Node *node = &lg.nodes[from];

		SlObject(node, _node_desc);

		for (NodeID to = 0; to < size; ++to) {

			SlObject(&lg.edges[from][to], _edge_desc);

		}

	}

}

/**

 * Save a link graph.

 * @param lg LinkGraph to be saved.

 */

static void DoSave_LGRP(LinkGraph *lg)

{

	_num_nodes = lg->Size();

	SlObject(lg, GetLinkGraphDesc());

	SaveLoad_LinkGraph(*lg);

}

/**

 * Load all link graphs.

 */

static void Load_LGRP()

{

	int index;

	while ((index = SlIterateArray()) != -1) {

		if (!LinkGraph::CanAllocateItem()) {

			/* Impossible as they have been present in previous game. */

			NOT_REACHED();

		}

		LinkGraph *lg = new (index) LinkGraph();

		SlObject(lg, GetLinkGraphDesc());

		lg->Init(_num_nodes);

		SaveLoad_LinkGraph(*lg);

	}

}

/**

 * Save all link graphs.

 */

static void Save_LGRP()

{

	LinkGraph *lg;

	FOR_ALL_LINK_GRAPHS(lg) {

		SlSetArrayIndex(lg->index);

		SlAutolength((AutolengthProc*)DoSave_LGRP, lg);

	}

}

extern const ChunkHandler _linkgraph_chunk_handlers[] = {

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

};

#include "../linkgraph/linkgraph.h"

extern const ChunkHandler _linkgraph_chunk_handlers[];

	_linkgraph_chunk_handlers,

		case REF_ENGINE_RENEWS:  return ((const       EngineRenew*)obj)->index + 1;

		case REF_CARGO_PACKET:   return ((const       CargoPacket*)obj)->index + 1;

		case REF_ORDERLIST:      return ((const         OrderList*)obj)->index + 1;

		case REF_STORAGE:        return ((const PersistentStorage*)obj)->index + 1;

		case REF_LINK_GRAPH:     return ((const         LinkGraph*)obj)->index + 1;

		case REF_LINK_GRAPH:

			if (LinkGraph::IsValidID(index)) return LinkGraph::Get(index);

			SlErrorCorrupt("Referencing invalid LinkGraph");

	REF_ORDER          =  0, ///< Load/save a reference to an order.

	REF_VEHICLE        =  1, ///< Load/save a reference to a vehicle.

	REF_STATION        =  2, ///< Load/save a reference to a station.

	REF_TOWN           =  3, ///< Load/save a reference to a town.

	REF_VEHICLE_OLD    =  4, ///< Load/save an old-style reference to a vehicle (for pre-4.4 savegames).

	REF_ROADSTOPS      =  5, ///< Load/save a reference to a bus/truck stop.

	REF_ENGINE_RENEWS  =  6, ///< Load/save a reference to an engine renewal (autoreplace).

	REF_CARGO_PACKET   =  7, ///< Load/save a reference to a cargo packet.

	REF_ORDERLIST      =  8, ///< Load/save a reference to an orderlist.

	REF_STORAGE        =  9, ///< Load/save a reference to a persistent storage.

	REF_LINK_GRAPH     = 10, ///< Load/save a reference to a link graph.

	REF_LINK_GRAPH_JOB = 11, ///< Load/save a reference to a link graph job.

void AfterLoadLinkGraphs();