newgrf_storage.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#ifndef NEWGRF_STORAGE_H
#define NEWGRF_STORAGE_H
 
#include "core/pool_type.hpp"
#include "tile_type.h"
 
enum PersistentStorageMode {
  PSM_ENTER_GAMELOOP,   
  PSM_LEAVE_GAMELOOP,   
  PSM_ENTER_COMMAND,    
  PSM_LEAVE_COMMAND,    
  PSM_ENTER_TESTMODE,   
  PSM_LEAVE_TESTMODE,   
};
 
struct BasePersistentStorageArray {
  uint32 grfid;    
  byte feature;    
  TileIndex tile;  
 
  virtual ~BasePersistentStorageArray();
 
  static void SwitchMode(PersistentStorageMode mode, bool ignore_prev_mode = false);
 
protected:
  virtual void ClearChanges() = 0;
 
  static bool AreChangesPersistent() { return (gameloop || command) && !testmode; }
 
private:
  static bool gameloop;
  static bool command;
  static bool testmode;
};
 
template <typename TYPE, uint SIZE>
struct PersistentStorageArray : BasePersistentStorageArray {
  TYPE storage[SIZE]; 
  TYPE *prev_storage; 
 
  PersistentStorageArray() : prev_storage(nullptr)
  {
    memset(this->storage, 0, sizeof(this->storage));
  }
 
  ~PersistentStorageArray()
  {
    free(this->prev_storage);
  }
 
  void ResetToZero()
  {
    memset(this->storage, 0, sizeof(this->storage));
  }
 
  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 (AreChangesPersistent()) {
      assert(this->prev_storage == nullptr);
    } else if (this->prev_storage == nullptr) {
      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 */
      AddChangedPersistentStorage(this);
    }
 
    this->storage[pos] = value;
  }
 
  TYPE GetValue(uint pos) const
  {
    /* Out of the scope of the array */
    if (pos >= SIZE) return 0;
 
    return this->storage[pos];
  }
 
  void ClearChanges()
  {
    if (this->prev_storage != nullptr) {
      memcpy(this->storage, this->prev_storage, sizeof(this->storage));
      free(this->prev_storage);
      this->prev_storage = nullptr;
    }
  }
};
 
 
template <typename TYPE, uint SIZE>
struct TemporaryStorageArray {
  TYPE storage[SIZE]; 
  uint16 init[SIZE];  
  uint16 init_key;    
 
  TemporaryStorageArray()
  {
    memset(this->storage, 0, sizeof(this->storage)); // not exactly needed, but makes code analysers happy
    memset(this->init, 0, sizeof(this->init));
    this->init_key = 1;
  }
 
  void StoreValue(uint pos, int32 value)
  {
    /* Out of the scope of the array */
    if (pos >= SIZE) return;
 
    this->storage[pos] = value;
    this->init[pos] = this->init_key;
  }
 
  TYPE GetValue(uint pos) const
  {
    /* Out of the scope of the array */
    if (pos >= SIZE) return 0;
 
    if (this->init[pos] != this->init_key) {
      /* Unassigned since last call to ClearChanges */
      return 0;
    }
 
    return this->storage[pos];
  }
 
  void ClearChanges()
  {
    /* Increment init_key to invalidate all storage */
    this->init_key++;
    if (this->init_key == 0) {
      /* When init_key wraps around, we need to reset everything */
      memset(this->init, 0, sizeof(this->init));
      this->init_key = 1;
    }
  }
};
 
void AddChangedPersistentStorage(BasePersistentStorageArray *storage);
 
typedef PersistentStorageArray<int32, 16> OldPersistentStorage;
 
typedef uint32 PersistentStorageID;
 
struct PersistentStorage;
typedef Pool<PersistentStorage, PersistentStorageID, 1, 0xFF000> PersistentStoragePool;
 
extern PersistentStoragePool _persistent_storage_pool;
 
struct PersistentStorage : PersistentStorageArray<int32, 256>, PersistentStoragePool::PoolItem<&_persistent_storage_pool> {
  PersistentStorage(const uint32 new_grfid, byte feature, TileIndex tile)
  {
    this->grfid = new_grfid;
    this->feature = feature;
    this->tile = tile;
  }
};
 
static_assert(cpp_lengthof(OldPersistentStorage, storage) <= cpp_lengthof(PersistentStorage, storage));
 
#endif /* NEWGRF_STORAGE_H */