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

#include "core/alloc_func.hpp"

     9

    10

/**

    11

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

    12

 * so we have a generalised class to use.

    13

 */

    14

struct BaseStorageArray

    15

{

    16

	/** The needed destructor */

    17

	virtual ~BaseStorageArray() {}

    18

    19

	/**

    20

	 * Clear the changes made since the last ClearChanges.

    21

	 * This can be done in two ways:

    22

	 *  - saving the changes permanently

    23

	 *  - reverting to the previous version

    24

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

    25

	 */

    26

	virtual void ClearChanges(bool keep_changes) = 0;

    27

    28

	/**

    29

	 * Stores some value at a given position.

    30

	 * @param pos   the position to write at

    31

	 * @param value the value to write

    32

	 */

    33

	virtual void Store(uint pos, uint32 value) = 0;

    34

};

    35

    36

/**

    37

 * Class for persistent storage of data.

    38

 * On ClearChanges that data is either reverted or saved.

    39

 * @param TYPE the type of variable to store.

    40

 * @param SIZE the size of the array.

    41

 */

    42

template <typename TYPE, uint SIZE>

    43

struct PersistentStorageArray : BaseStorageArray {

    44

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

    45

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

    46

    47

	/** Simply construct the array */

    48

	PersistentStorageArray() : prev_storage(NULL)

    49

	{

    50

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

    51

	}

    52

    53

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

    54

	~PersistentStorageArray()

    55

	{

    56

		free(this->prev_storage);

    57

	}

    58

    59

	/**

    60

	 * Stores some value at a given position.

    61

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

    62

	 * we write the data.

    63

	 * @param pos   the position to write at

    64

	 * @param value the value to write

    65

	 */

    66

	void Store(uint pos, uint32 value)

    67

	{

    68

		/* Out of the scope of the array */

    69

		if (pos >= SIZE) return;

    70

    71

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

    72

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

    73

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

    74

    75

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

    76

		if (this->prev_storage != NULL) {

    77

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

    78

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

    79

    80

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

    81

    82

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

    83

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

    84

			AddChangedStorage(this);

    85

		}

    86

    87

		this->storage[pos] = value;

    88

	}

    89

    90

	/**

    91

	 * Gets the value from a given position.

    92

	 * @param pos the position to get the data from

    93

	 * @return the data from that position

    94

	 */

    95

	TYPE Get(uint pos) const

    96

	{

    97

		/* Out of the scope of the array */

    98

		if (pos >= SIZE) return 0;

    99

   100

		return this->storage[pos];

   101

	}

   102

   103

	void ClearChanges(bool keep_changes)

   104

	{

   105

		assert(this->prev_storage != NULL);

   106

   107

		if (!keep_changes) {

   108

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

   109

		}

   110

		free(this->prev_storage);

   111

	}

   112

};

   113

   114

   115

/**

   116

 * Class for temporary storage of data.

   117

 * On ClearChanges that data is always zero-ed.

   118

 * @param TYPE the type of variable to store.

   119

 * @param SIZE the size of the array.

   120

 */

   121

template <typename TYPE, uint SIZE>

   122

struct TemporaryStorageArray : BaseStorageArray {

   123

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

   124

   125

	/** Simply construct the array */

   126

	TemporaryStorageArray()

   127

	{

   128

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

   129

	}

   130

   131

	/**

   132

	 * Stores some value at a given position.

   133

	 * @param pos   the position to write at

   134

	 * @param value the value to write

   135

	 */

   136

	void Store(uint pos, uint32 value)

   137

	{

   138

		/* Out of the scope of the array */

   139

		if (pos >= SIZE) return;

   140

   141

		this->storage[pos] = value;

   142

		AddChangedStorage(this);

   143

	}

   144

   145

	/**

   146

	 * Gets the value from a given position.

   147

	 * @param pos the position to get the data from

   148

	 * @return the data from that position

   149

	 */

   150

	TYPE Get(uint pos) const

   151

	{

   152

		/* Out of the scope of the array */

   153

		if (pos >= SIZE) return 0;

   154

   155

		return this->storage[pos];

   156

	}

   157

   158

	void ClearChanges(bool keep_changes)

   159

	{

   160

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

   161

	}

   162

};

   163

   164

/**

   165

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

   166

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

   167

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

   168

 * @param storage the array that has changed

   169

 */

   170

void AddChangedStorage(BaseStorageArray *storage);

   171

   172

   173

/**

   174

 * Clear the changes made since the last ClearStorageChanges.

   175

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

   176

 * AddChangedStorage since the previous ClearStorageChanges.

   177

 *

   178

 * This can be done in two ways:

   179

 *  - saving the changes permanently

   180

 *  - reverting to the previous version

   181

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

   182

 */

   183

void ClearStorageChanges(bool keep_changes);

   184

   185

#endif /* NEWGRF_STORAGE_H */