/* $Id$ */ /* * This file is part of OpenTTD. * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2. * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>. */ /** @file newgrf_storage.h Functionality related to the temporary and persistent storage arrays for NewGRFs. */ #ifndef NEWGRF_STORAGE_H #define NEWGRF_STORAGE_H #include "core/alloc_func.hpp" #include "core/pool_type.hpp" /** * Base class for all NewGRF storage arrays. Nothing fancy, only here * so we have a generalised class to use. */ struct BaseStorageArray { virtual ~BaseStorageArray(); /** * Clear the changes made since the last ClearChanges. * This can be done in two ways: * - saving the changes permanently * - reverting to the previous version * @param keep_changes do we save or revert the changes since the last ClearChanges? */ virtual void ClearChanges(bool keep_changes) = 0; /** * Stores some value at a given position. * @param pos the position to write at * @param value the value to write */ virtual void StoreValue(uint pos, int32 value) = 0; }; /** * Class for persistent storage of data. * On ClearChanges that data is either reverted or saved. * @param TYPE the type of variable to store. * @param SIZE the size of the array. */ template <typename TYPE, uint SIZE> struct PersistentStorageArray : BaseStorageArray { TYPE storage[SIZE]; ///< Memory to for the storage array TYPE *prev_storage; ///< Memory to store "old" states so we can revert them on the performance of test cases for commands etc. /** Simply construct the array */ PersistentStorageArray() : prev_storage(NULL) { memset(this->storage, 0, sizeof(this->storage)); } /** And free all data related to it */ ~PersistentStorageArray() { free(this->prev_storage); } /** Resets all values to zero. */ void ResetToZero() { memset(this->storage, 0, sizeof(this->storage)); } /** * Stores some value at a given position. * If there is no backup of the data that backup is made and then * we write the data. * @param pos the position to write at * @param value the value to write */ void StoreValue(uint pos, int32 value) { /* Out of the scope of the array */ if (pos >= SIZE) return; /* The value hasn't changed, so we pretend nothing happened. * Saves a few cycles and such and it's pretty easy to check. */ if (this->storage[pos] == value) return; /* We do not have made a backup; lets do so */ if (this->prev_storage != NULL) { this->prev_storage = MallocT<TYPE>(SIZE); memcpy(this->prev_storage, this->storage, sizeof(this->storage)); /* We only need to register ourselves when we made the backup * as that is the only time something will have changed */ AddChangedStorage(this); } this->storage[pos] = value; } /** * Gets the value from a given position. * @param pos the position to get the data from * @return the data from that position */ TYPE GetValue(uint pos) const { /* Out of the scope of the array */ if (pos >= SIZE) return 0; return this->storage[pos]; } /** * Clear the changes, or assign them permanently to the storage. * @param keep_changes Whether to assign or ditch the changes. */ void ClearChanges(bool keep_changes) { assert(this->prev_storage != NULL); if (!keep_changes) { memcpy(this->storage, this->prev_storage, sizeof(this->storage)); } free(this->prev_storage); } }; /** * Class for temporary storage of data. * On ClearChanges that data is always zero-ed. * @param TYPE the type of variable to store. * @param SIZE the size of the array. */ template <typename TYPE, uint SIZE> struct TemporaryStorageArray : BaseStorageArray { TYPE storage[SIZE]; ///< Memory to for the storage array /** Simply construct the array */ TemporaryStorageArray() { memset(this->storage, 0, sizeof(this->storage)); } /** * Stores some value at a given position. * @param pos the position to write at * @param value the value to write */ void StoreValue(uint pos, int32 value) { /* Out of the scope of the array */ if (pos >= SIZE) return; this->storage[pos] = value; AddChangedStorage(this); } /** * Gets the value from a given position. * @param pos the position to get the data from * @return the data from that position */ TYPE GetValue(uint pos) const { /* Out of the scope of the array */ if (pos >= SIZE) return 0; return this->storage[pos]; } void ClearChanges(bool keep_changes) { memset(this->storage, 0, sizeof(this->storage)); } }; void AddChangedStorage(BaseStorageArray *storage); void ClearStorageChanges(bool keep_changes); typedef PersistentStorageArray<int32, 16> OldPersistentStorage; typedef uint32 PersistentStorageID; struct PersistentStorage; typedef Pool<PersistentStorage, PersistentStorageID, 1, 0xFF000> PersistentStoragePool; extern PersistentStoragePool _persistent_storage_pool; /** * Class for pooled persistent storage of data. * On ClearChanges that data is always zero-ed. */ struct PersistentStorage : PersistentStorageArray<int32, 16>, PersistentStoragePool::PoolItem<&_persistent_storage_pool> { uint32 grfid; ///< GRFID associated to this persistent storage. A value of zero means "default". /** We don't want GCC to zero our struct! It already is zeroed and has an index! */ PersistentStorage(const uint32 new_grfid) : grfid(new_grfid) { this->prev_storage = NULL; memset(this->storage, 0, sizeof(this->storage)); } /** Free the memory used by the persistent storage. */ ~PersistentStorage() { free(this->prev_storage); } }; assert_compile(cpp_lengthof(OldPersistentStorage, storage) == cpp_lengthof(PersistentStorage, storage)); #define FOR_ALL_STORAGES_FROM(var, start) FOR_ALL_ITEMS_FROM(PersistentStorage, storage_index, var, start) #define FOR_ALL_STORAGES(var) FOR_ALL_STORAGES_FROM(var, 0) #endif /* NEWGRF_STORAGE_H */