1

/* $Id$ */

     2

     3

/** @file ai_transactionmode.hpp Switch the AI to Transaction Mode. */

     4

     5

#ifndef AI_TRANSACTIONMODE_HPP

     6

#define AI_TRANSACTIONMODE_HPP

     7

     8

#include "ai_object.hpp"

    10

#include <queue>

    11

    12

/**

    13

 * Class to switch current mode to Transaction mode.

    14

 * If you create an instance of this class, the mode will be switched to

    15

 *   Transaction. The original mode is stored and recovered from when ever the

    16

 *   instance is destroyed.

    17

 * In Transaction mode all commands will be tested, and if not fail, queued.

    18

 *   Later on you can execute a queue for real. The Transaction keeps on

    19

 *   recording all commands till it is destructed or execute or stopped.

    20

 * On execute the transaction can return false, because maps change over time.

    21

 *   If this happens you can use the rollback feature to remove all already

    22

 *   built things.

    23

 */

    24

class AITransactionMode : public AIObject {

    25

public:

    26

	static const char *GetClassName() { return "AITransactionMode"; }

    27

    28

private:

    29

	struct AITransactionModeCommand {

    30

		TileIndex tile;

    31

		uint32 p1;

    32

		uint32 p2;

    33

		uint procc;

    34

		char *text;

    35

	};

    36

    37

	AIModeProc *last_mode;

    38

	AIObject *last_instance;

    39

	std::queue<AITransactionModeCommand> command_stack;

    40

	std::queue<AITransactionModeCommand> reverse_stack;

    41

	bool stopped;

    42

	CommandCost costs;

    43

    44

protected:

    45

	/**

    46

	 * The callback proc for Transaction mode.

    47

	 */

    48

	static bool ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs);

    49

    50

public:

    51

	/**

    52

	 * Creating instance of this class switches the build mode to Transaction.

    53

	 * @note When the instance is destroyed, he restores the mode that was

    54

	 *   current when the instance was created!

    55

	 */

    56

	AITransactionMode();

    57

    58

	/**

    59

	 * Destroying this instance reset the building mode to the mode it was

    60

	 *   in when the instance was created.

    61

	 */

    62

	~AITransactionMode();

    63

    64

	/**

    65

	 * Execute all recorded commands.

    66

	 * @return False if any command recorded failed to execute. All other

    67

	 *   commands that follow won't be executed either.

    68

	 * @note When Execute() is called, the transaction is stopped (like calling

    69

	 *   Stop() yourself).

    70

	 * @note Execute() is always executed, no matter what mode you gave it in

    71

	 *   the outside world. It forces itself into executing it for real. To add

    72

	 *   it to an other list, use Append().

    73

	 */

    74

	bool Execute();

    75

    76

	/**

    77

	 * Stop recording the commands and switch to the last mode, like the

    78

	 *   instance was destroyed.

    79

	 */

    80

	void Stop();

    81

    82

	/**

    83

	 * Rollbacks rolls the whole transaction back in case Execute() returned

    84

	 *   false. In case Execute() returned true, there won't be anything to roll

    85

	 *   back, so this command will do nothing.

    86

	 * It rolls back all commands by looking up the reverse of every command

    87

	 *   issued and executes that. Of course it can happen that even that fails.

    88

	 *   In that case the problem will be silently ignored.

    89

	 * @note As you might want to get a costs estimate about the rollback first

    90

	 *   you need to make sure you set the right mode yourself!

    91

	 * @note This command isn't finished yet!!

    92

	 */

    93

	void Rollback();

    94

    95

	/**

    96

	 * Get the costs it takes to execute this transaction (on average, real

    97

	 *   numbers can always differ).

    98

	 * @return The costs of this transaction.

    99

	 */

   100

	Money GetCosts();

   101

   102

	/**

   103

	 * Append one transaction list to an other.

   104

	 * @param transaction The list that will be appended after the instance you call append on.

   105

	 */

   106

	void Append(AITransactionMode *transaction);

   107

};

   108

   109

#endif /* AI_TRANSACTIONMODE_HPP */