1

/* $Id$ */

     2

     3

/** @file cargotype.h */

     4

     5

#ifndef CARGOPACKET_H

     6

#define CARGOPACKET_H

     7

     8

#include <list>

     9

    10

/**

    11

 * Container for cargo from the same location and time

    12

 */

    13

struct CargoPacket {

    14

	typedef uint32 ID;      ///< Type for cargopacket identifiers

    15

    16

	ID index;               ///< The unique index of this packet

    17

    18

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

    19

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

    20

	TileIndex loaded_at_xy; ///< Location where this cargo has been loaded into the vehicle

    21

    22

	uint16 count;           ///< The amount of cargo in this packet

    23

	byte days_in_transit;   ///< Amount of days this packet has been in transit

    24

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

    25

	bool paid_for;          ///< Have we been paid for this cargo packet?

    26

    27

	/**

    28

	 * Creates a new cargo packet

    29

	 * @param source the source of the packet

    30

	 * @param count  the number of cargo entities to put in this packet

    31

	 * @pre count != 0 || source == INVALID_STATION

    32

	 */

    33

	CargoPacket(StationID source = INVALID_STATION, uint16 count = 0);

    34

    35

	/** Destroy the packet */

    36

	~CargoPacket();

    37

    38

    39

	/**

    40

	 * Is this a valid cargo packet ?

    41

	 * @return true if and only it is valid

    42

	 */

    43

	bool IsValid() const { return this->count != 0; }

    44

    45

	/**

    46

	 * Checks whether the cargo packet is from (exactly) the same source

    47

	 * in time and location.

    48

	 * @param cp the cargo packet to compare to

    49

	 * @return true if and only if days_in_transit and source_xy are equal

    50

	 */

    51

	bool SameSource(CargoPacket *cp);

    52

    53

    54

	/* normal new/delete operators. Used when building/removing station */

    55

	void* operator new (size_t size);

    56

	void operator delete(void *p);

    57

    58

	/* new/delete operators accepting station index. Used when loading station from savegame. */

    59

	void* operator new (size_t size, CargoPacket::ID cp_idx);

    60

	void operator delete(void *p, CargoPacket::ID cp_idx);

    61

    62

private:

    63

	/**

    64

	 * Allocate the raw memory for this cargo packet

    65

	 * @return the allocated memory

    66

	 */

    67

	static CargoPacket *AllocateRaw();

    68

};

    69

    70

/** We want to use a pool */

    71

DECLARE_OLD_POOL(CargoPacket, CargoPacket, 10, 1000)

    72

    73

/**

    74

 * Iterate over all _valid_ cargo packets from the given start

    75

 * @param cp    the variable used as "iterator"

    76

 * @param start the cargo packet ID of the first packet to iterate over

    77

 */

    78

#define FOR_ALL_CARGOPACKETS_FROM(cp, start) for (cp = GetCargoPacket(start); cp != NULL; cp = (cp->index + 1U < GetCargoPacketPoolSize()) ? GetCargoPacket(cp->index + 1U) : NULL) if (cp->IsValid())

    79

    80

/**

    81

 * Iterate over all _valid_ cargo packets from the begin of the pool

    82

 * @param cp    the variable used as "iterator"

    83

 */

    84

#define FOR_ALL_CARGOPACKETS(cp) FOR_ALL_CARGOPACKETS_FROM(cp, 0)

    85

    86

/**

    87

 * Simple collection class for a list of cargo packets

    88

 */

    89

class CargoList {

    90

public:

    91

	/** List of cargo packets */

    92

	typedef std::list<CargoPacket *> List;

    93

    94

	/** Kind of actions that could be done with packets on move */

    95

	enum MoveToAction {

    96

		MTA_FINAL_DELIVERY, ///< "Deliver" the packet to the final destination, i.e. destroy the packet

    97

		MTA_CARGO_LOAD,     ///< Load the packet onto a vehicle, i.e. set the last loaded station ID

    98

		MTA_OTHER           ///< "Just" move the packet to another cargo list

    99

	};

   100

   101

private:

   102

	List packets;         ///< The cargo packets in this list

   103

   104

	bool empty;           ///< Cache for whether this list is empty or not

   105

	uint count;           ///< Cache for the number of cargo entities

   106

	bool unpaid_cargo;    ///< Cache for the unpaid cargo

   107

	Money feeder_share;   ///< Cache for the feeder share

   108

	StationID source;     ///< Cache for the source of the packet

   109

	uint days_in_transit; ///< Cache for the number of days in transit

   110

   111

public:

   112

	/**

   113

	 * Needed for an ugly hack:

   114

	 *  - vehicles and stations need to store cargo lists, so they use CargoList as container

   115

	 *  - this internals of the container should be protected, e.g. private (or protected) by C++

   116

	 *  - for saving/loading we need to pass pointer to objects

   117

	 *  -> so *if* the pointer to the cargo list is the same as the pointer to the packet list

   118

	 *     encapsulated in the CargoList, we can just pass the CargoList as "offset".

   119

	 *     Normally we would then just add the offset of the packets variable within the cargo list

   120

	 *     but that is not possible because the variable is private. Furthermore we are not sure

   121

	 *     that this works on all platforms, we need to check whether the offset is actually 0.

   122

	 *     This cannot be done compile time, because the variable is private. So we need to write

   123

	 *     a function that does actually check the offset runtime and call it somewhere where it

   124

	 *     is always called but it should not be called often.

   125

	 */

   126

	static void AssertOnWrongPacketOffset();

   127

   128

	/** Create the cargo list */

   129

	CargoList() { this->InvalidateCache(); }

   130

	/** And destroy it ("frees" all cargo packets) */

   131

	~CargoList();

   132

   133

	/**

   134

	 * Returns a pointer to the cargo packet list (so you can iterate over it etc).

   135

	 * @return pointer to the packet list

   136

	 */

   137

	const CargoList::List *Packets() const;

   138

   139

	/**

   140

	 * Ages the all cargo in this list

   141

	 */

   142

	void AgeCargo();

   143

   144

	/**

   145

	 * Checks whether this list is empty

   146

	 * @return true if and only if the list is empty

   147

	 */

   148

	bool Empty() const;

   149

   150

	/**

   151

	 * Returns the number of cargo entities in this list

   152

	 * @return the before mentioned number

   153

	 */

   154

	uint Count() const;

   155

   156

	/**

   157

	 * Is there some cargo that has not been paid for?

   158

	 * @return true if and only if there is such a cargo

   159

	 */

   160

	bool UnpaidCargo() const;

   161

   162

	/**

   163

	 * Returns total sum of the feeder share for all packets

   164

	 * @return the before mentioned number

   165

	 */

   166

	Money FeederShare() const;

   167

   168

	/**

   169

	 * Returns source of the first cargo packet in this list

   170

	 * @return the before mentioned source

   171

	 */

   172

	StationID Source() const;

   173

   174

	/**

   175

	 * Returns average number of days in transit for a cargo entity

   176

	 * @return the before mentioned number

   177

	 */

   178

	uint DaysInTransit() const;

   179

   180

   181

	/**

   182

	 * Appends the given cargo packet

   183

	 * @warning After appending this packet may not exist anymore!

   184

	 * @note Do not use the cargo packet anymore after it has been appended to this CargoList!

   185

	 * @param cp the cargo packet to add

   186

	 * @pre cp != NULL

   187

	 */

   188

	void Append(CargoPacket *cp);

   189

   190

	/**

   191

	 * Truncates the cargo in this list to the given amount. It leaves the

   192

	 * first count cargo entities and removes the rest.

   193

	 * @param count the maximum amount of entities to be in the list after the command

   194

	 */

   195

	void Truncate(uint count);

   196

   197

	/**

   198

	 * Moves the given amount of cargo to another list.

   199

	 * Depending on the value of mta the side effects of this function differ:

   200

	 *  - MTA_FINAL_DELIVERY: destroys the packets that do not originate from a specific station

   201

	 *  - MTA_CARGO_LOAD:     sets the loaded_at_xy value of the moved packets

   202

	 *  - MTA_OTHER:          just move without side effects

   203

	 * @param dest  the destination to move the cargo to

   204

	 * @param count the amount of cargo entities to move

   205

	 * @param mta   how to handle the moving (side effects)

   206

	 * @param data  Depending on mta the data of this variable differs:

   207

	 *              - MTA_FINAL_DELIVERY - station ID of packet's origin not to remove

   208

	 *              - MTA_CARGO_LOAD     - station's tile index of load

   209

	 *              - MTA_OTHER          - unused

   210

	 * @param mta == MTA_FINAL_DELIVERY || dest != NULL

   211

	 * @return true if there are still packets that might be moved from this cargo list

   212

	 */

   213

	bool MoveTo(CargoList *dest, uint count, CargoList::MoveToAction mta = MTA_OTHER, uint data = 0);

   214

   215

	/** Invalidates the cached data and rebuild it */

   216

	void InvalidateCache();

   217

};

   218

   219

#endif /* CARGOPACKET_H */