1

/* $Id$ */

     2

     3

/** @file newgrf_storage.h Functionality related to the temporary and persistent storage arrays for NewGRFs. */

     4

     5

#ifndef NEWGRF_STORAGE_H

     6

#define NEWGRF_STORAGE_H

     7

     8

/**

     9

 * Base class for all NewGRF storage arrays. Nothing fancy, only here

    10

 * so we have a generalised class to use.

    11

 */

    12

struct BaseStorageArray

    13

{

    14

	/** The needed destructor */

    15

	virtual ~BaseStorageArray() {}

    16

    17

	/**

    18

	 * Clear the changes made since the last ClearChanges.

    19

	 * This can be done in two ways:

    20

	 *  - saving the changes permanently

    21

	 *  - reverting to the previous version

    22

	 * @param keep_changes do we save or revert the changes since the last ClearChanges?

    23

	 */

    32

};

    33

    34

/**

    35

 * Class for persistent storage of data.

    36

 * On ClearChanges that data is either reverted or saved.

    37

 * @param TYPE the type of variable to store.

    38

 * @param SIZE the size of the array.

    39

 */

    40

template <typename TYPE, uint SIZE>

    41

struct PersistentStorageArray : BaseStorageArray {

    42

	TYPE storage[SIZE]; ///< Memory to for the storage array

    43

	TYPE *prev_storage; ///< Memory to store "old" states so we can revert them on the performance of test cases for commands etc.

    44

    45

	/** Simply construct the array */

    46

	PersistentStorageArray() : prev_storage(NULL)

    47

	{

    48

		memset(this->storage, 0, sizeof(this->storage));

    49

	}

    50

    51

	/** And free all data related to it */

    52

	~PersistentStorageArray()

    53

	{

    54

		free(this->prev_storage);

    55

	}

    56

    57

	/**

    58

	 * Stores some value at a given position.

    59

	 * If there is no backup of the data that backup is made and then

    60

	 * we write the data.

    61

	 * @param pos   the position to write at

    62

	 * @param value the value to write

    63

	 */

    65

	{

    66

		/* Out of the scope of the array */

    67

		if (pos >= SIZE) return;

    68

    69

		/* The value hasn't changed, so we pretend nothing happened.

    70

		 * Saves a few cycles and such and it's pretty easy to check. */

    71

		if (this->storage[pos] == value) return;

    72

    73

		/* We do not have made a backup; lets do so */

    74

		if (this->prev_storage != NULL) {

    75

			this->prev_storage = MallocT<TYPE>(SIZE);

    76

			if (this->prev_storage == NULL) return;

    77

    78

			memcpy(this->prev_storage, this->storage, sizeof(this->storage));

    79

    80

			/* We only need to register ourselves when we made the backup

    81

			 * as that is the only time something will have changed */

    82

			AddChangedStorage(this);

    83

		}

    84

    85

		this->storage[pos] = value;

    86

	}

    87

    88

	/**

    89

	 * Gets the value from a given position.

    90

	 * @param pos the position to get the data from

    91

	 * @return the data from that position

    92

	 */

    94

	{

    95

		/* Out of the scope of the array */

    96

		if (pos >= SIZE) return 0;

    97

    98

		return this->storage[pos];

    99

	}

   100

   101

	void ClearChanges(bool keep_changes)

   102

	{

   103

		assert(this->prev_storage != NULL);

   104

   105

		if (!keep_changes) {

   106

			memcpy(this->storage, this->prev_storage, sizeof(this->storage));

   107

		}

   108

		free(this->prev_storage);

   109

	}

   110

};

   111

   112

   113

/**

   114

 * Class for temporary storage of data.

   115

 * On ClearChanges that data is always zero-ed.

   116

 * @param TYPE the type of variable to store.

   117

 * @param SIZE the size of the array.

   118

 */

   119

template <typename TYPE, uint SIZE>

   120

struct TemporaryStorageArray : BaseStorageArray {

   121

	TYPE storage[SIZE]; ///< Memory to for the storage array

   122

   123

	/** Simply construct the array */

   124

	TemporaryStorageArray()

   125

	{

   126

		memset(this->storage, 0, sizeof(this->storage));

   127

	}

   128

   129

	/**

   130

	 * Stores some value at a given position.

   131

	 * @param pos   the position to write at

   132

	 * @param value the value to write

   133

	 */

   135

	{

   136

		/* Out of the scope of the array */

   137

		if (pos >= SIZE) return;

   138

   139

		this->storage[pos] = value;

   140

		AddChangedStorage(this);

   141

	}

   142

   143

	/**

   144

	 * Gets the value from a given position.

   145

	 * @param pos the position to get the data from

   146

	 * @return the data from that position

   147

	 */

   149

	{

   150

		/* Out of the scope of the array */

   151

		if (pos >= SIZE) return 0;

   152

   153

		return this->storage[pos];

   154

	}

   155

   156

	void ClearChanges(bool keep_changes)

   157

	{

   158

		memset(this->storage, 0, sizeof(this->storage));

   159

	}

   160

};

   161

   162

/**

   163

 * Add the changed storage array to the list of changed arrays.

   164

 * This is done so we only have to revert/save the changed

   165

 * arrays, which saves quite a few clears, etc. after callbacks.

   166

 * @param storage the array that has changed

   167

 */

   168

void AddChangedStorage(BaseStorageArray *storage);

   169

   170

   171

/**

   172

 * Clear the changes made since the last ClearStorageChanges.

   173

 * This is done for *all* storages that have been registered to with

   174

 * AddChangedStorage since the previous ClearStorageChanges.

   175

 *

   176

 * This can be done in two ways:

   177

 *  - saving the changes permanently

   178

 *  - reverting to the previous version

   179

 * @param keep_changes do we save or revert the changes since the last ClearChanges?

   180

 */

   181

void ClearStorageChanges(bool keep_changes);

   182

   183

#endif /* NEWGRF_STORAGE_H */