{

	CargoPacket *cp_new = this->Preprocess(cp);

	if (cp_new == nullptr) return false;

	this->source->RemoveFromCache(cp_new, cp_new->Count());

	this->destination->Append(cp_new, VehicleCargoList::MTA_KEEP);

	return cp_new == cp;

{

	CargoPacket *cp_new = this->Preprocess(cp);

	if (cp_new == nullptr) return false;

	this->source->reserved_count += cp_new->Count();

	this->source->RemoveFromCache(cp_new, cp_new->Count());

	this->destination->Append(cp_new, VehicleCargoList::MTA_LOAD);

/** Action of loading cargo from a station onto a vehicle. */

class CargoLoad : public CargoMovement<StationCargoList, VehicleCargoList> {

public:

	bool operator()(CargoPacket *cp);

};

/** Action of reserving cargo from a station to be loaded onto a vehicle. */

class CargoReservation : public CargoLoad {

public:

	bool operator()(CargoPacket *cp);

};

	periods_in_transit(0),

	feeder_share(0),

	source_xy(source_xy),

	source_id(source_id),

	source(source),

	source_type(source_type)

 * @param periods_in_transit Number of cargo aging periods the cargo has been in transit.

 * @param source          Station the cargo was initially loaded.

 * @param source_xy       Station location the cargo was initially loaded.

 * @param feeder_share    Feeder share the packet has already accumulated.

 * @param source_type     'Type' of source the packet comes from (for subsidies).

 * @param source_id       Actual source of the packet (for subsidies).

 * @note We have to zero memory ourselves here because we are using a 'new'

 * that, in contrary to all other pools, does not memset to 0.

 */

		count(count),

		periods_in_transit(periods_in_transit),

		feeder_share(feeder_share),

		source_xy(source_xy),

		source_id(source_id),

		source(source),

		source_type(source_type)

	if (!CargoPacket::CanAllocateItem()) return nullptr;

	Money fs = this->FeederShare(new_size);

	this->feeder_share -= fs;

	this->count -= new_size;

	return cp_new;

}

/**

 * Choose action to be performed with the given cargo packet.

 * @param cp The packet.

 * @param cargo_next Next hop the cargo wants to pass.

 * Reserves cargo for loading onto the vehicle.

 * @param max_move Maximum amount of cargo to reserve.

 * @param dest VehicleCargoList to reserve for.

 * @param next_station Next station(s) the loading vehicle will visit.

 * @return Amount of cargo actually reserved.

 */

{

}

/**

 * Otherwise load cargo from the station.

 * @param max_move Amount of cargo to load.

 * @param dest Vehicle cargo list where the cargo resides.

 * @param next_station Next station(s) the loading vehicle will visit.

 * @return Amount of cargo actually loaded.

 * @note Vehicles may or may not reserve, depending on their orders. The two

 *       modes of loading are exclusive, though. If cargo is reserved we don't

 *       need to load unreserved cargo.

 */

{

	uint move = std::min(dest->ActionCount(VehicleCargoList::MTA_LOAD), max_move);

	if (move > 0) {

		dest->Reassign<VehicleCargoList::MTA_LOAD, VehicleCargoList::MTA_KEEP>(move);

		return move;

	} else {

	}

}

extern SaveLoadTable GetCargoPacketDesc();

/**

 * Container for cargo from the same location and time.

 */

struct CargoPacket : CargoPacketPool::PoolItem<&_cargopacket_pool> {

	uint16_t periods_in_transit; ///< Amount of cargo aging periods this packet has been in transit.

	Money feeder_share;     ///< Value of feeder pickup to be paid for on delivery of cargo.

	TileIndex source_xy;    ///< The origin of the cargo (first station in feeder chain).

	SourceID source_id;     ///< Index of source, INVALID_SOURCE if unknown/invalid.

	StationID source;       ///< The station where the cargo came from first.

	SourceType source_type; ///< Type of \c source_id.

	CargoPacket();

	CargoPacket(StationID source, TileIndex source_xy, uint16_t count, SourceType source_type, SourceID source_id);

	/** Destroy the packet. */

	~CargoPacket() { }

	void Reduce(uint count);

	/**

	 * Sets the station where the packet is supposed to go next.

	 * @param next_station Next station the packet should go to.

	 */

	}

	/**

	 * Gets the ID of station the cargo wants to go next.

	 * @return Next station for this packets.

	 */

	void InvalidateCache();

	bool Stage(bool accepted, StationID current_station, StationIDStack next_station, uint8_t order_flags, const GoodsEntry *ge, CargoPayment *payment);

	/**

		return cp1->source_xy == cp2->source_xy &&

				cp1->periods_in_transit == cp2->periods_in_transit &&

				cp1->source_type == cp2->source_type &&

	}

};

	 * amount of cargo to be moved. Second parameter is destination (if

	 * applicable), return value is amount of cargo actually moved. */

	uint Truncate(uint max_move = UINT_MAX, StationCargoAmountMap *cargo_per_source = nullptr);

	uint Reroute(uint max_move, StationCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge);

	{

		if (this->do_reserve) {

			this->st->goods[v->cargo_type].cargo.Reserve(v->cargo_cap - v->cargo.RemainingCount(),

		}

		this->consist_capleft[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();

		return true;

	{

		if (v->cargo_cap > v->cargo.RemainingCount() && MayLoadUnderExclusiveRights(st, v)) {

			st->goods[v->cargo_type].cargo.Reserve(v->cargo_cap - v->cargo.RemainingCount(),

		}

		return true;

				if (v->cargo.StoredCount() == 0) TriggerVehicle(v, VEHICLE_TRIGGER_NEW_CARGO);

				if (_settings_game.order.gradual_loading) cap_left = std::min(cap_left, GetLoadAmount(v));

				if (v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0) {

					/* Remember if there are reservations left so that we don't stop

					 * loading before they're loaded. */

			for (VehicleCargoList::ConstIterator it(packets->begin()); it != packets->end(); it++) {

				CargoPacket *cp = *it;

				cp->source_xy = Station::IsValidID(cp->source) ? Station::Get(cp->source)->xy : v->tile;

			}

		}

				for (StationCargoList::ConstIterator it(packets->begin()); it != packets->end(); it++) {

					CargoPacket *cp = *it;

					cp->source_xy = Station::IsValidID(cp->source) ? Station::Get(cp->source)->xy : st->xy;

				}

			}

		}

	static const SaveLoad _cargopacket_desc[] = {

		SLE_VAR(CargoPacket, source,          SLE_UINT16),

		SLE_VAR(CargoPacket, source_xy,       SLE_UINT32),

		SLE_VAR(CargoPacket, count,           SLE_UINT16),

		SLE_CONDVARNAME(CargoPacket, periods_in_transit, "days_in_transit", SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION, SLV_MORE_CARGO_AGE),

		SLE_CONDVARNAME(CargoPacket, periods_in_transit, "days_in_transit", SLE_UINT16, SLV_MORE_CARGO_AGE, SLV_PERIODS_IN_TRANSIT_RENAME),

const SaveLoadCompat _cargopacket_sl_compat[] = {

	SLC_VAR("source"),

	SLC_VAR("source_xy"),

	SLC_VAR("count"),

	SLC_VAR("days_in_transit"),

	SLC_VAR("feeder_share"),

	SLC_VAR("profit_this_year"),

	SLC_VAR("profit_last_year"),

	SLC_VAR("cargo_feeder_share"),

	SLC_VAR("value"),

	SLC_VAR("random_bits"),

	SLC_VAR("waiting_triggers"),

		if (_cargo_count != 0 && CargoPacket::CanAllocateItem()) {

			StationID source =    (_cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;

			TileIndex source_xy = (source != INVALID_STATION) ? Station::Get(source)->xy : (TileIndex)0;

		}

	}

	SLV_INDUSTRY_CARGO_REORGANISE,          ///< 315  PR#10853 Industry accepts/produced data reorganised.

	SLV_PERIODS_IN_TRANSIT_RENAME,          ///< 316  PR#11112 Rename days in transit to (cargo) periods in transit.

	SLV_NEWGRF_LAST_SERVICE,                ///< 317  PR#11124 Added stable date_of_last_service to avoid NewGRF trouble.

	SL_MAX_VERSION,                         ///< Highest possible saveload version

};

					assert(CargoPacket::CanAllocateItem());

					/* Don't construct the packet with station here, because that'll fail with old savegames */

					ge->cargo.Append(cp, INVALID_STATION);

					SB(ge->status, GoodsEntry::GES_RATING, 1, 1);

				}

static uint16_t _cargo_count;

static uint16_t _cargo_paid_for;

static Money  _cargo_feeder_share;

class SlVehicleCommon : public DefaultSaveLoadHandler<SlVehicleCommon, Vehicle> {

public:

		SLE_CONDVAR(Vehicle, profit_last_year,      SLE_INT64,                   SLV_65, SL_MAX_VERSION),

		SLEG_CONDVAR("cargo_feeder_share", _cargo_feeder_share, SLE_FILE_I32 | SLE_VAR_I64,  SLV_51,  SLV_65),

		SLEG_CONDVAR("cargo_feeder_share", _cargo_feeder_share, SLE_INT64,                   SLV_65,  SLV_68),

		SLE_CONDVAR(Vehicle, value,                 SLE_FILE_I32 | SLE_VAR_I64,   SL_MIN_VERSION,  SLV_65),

		SLE_CONDVAR(Vehicle, value,                 SLE_INT64,                   SLV_65, SL_MAX_VERSION),

			if (_cargo_count != 0 && IsCompanyBuildableVehicleType(v) && CargoPacket::CanAllocateItem()) {

				/* Don't construct the packet with station here, because that'll fail with old savegames */

				v->cargo.Append(cp);

			}

		if (cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0) {

			Debug(misc, 1, "cancelling cargo reservation");

			cargo.Return(UINT_MAX, &st->goods[v->cargo_type].cargo, next);

		}

		cargo.KeepAll();

	}