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 : uint8_t {
  PSM_ENTER_GAMELOOP,   
  PSM_LEAVE_GAMELOOP,   
  PSM_ENTER_COMMAND,    
  PSM_LEAVE_COMMAND,    
  PSM_ENTER_TESTMODE,   
  PSM_LEAVE_TESTMODE,   
};
 
struct BasePersistentStorageArray {
  uint32_t grfid = 0; 
  uint8_t feature = 0; 
  TileIndex tile = INVALID_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 {
  using StorageType = std::array<TYPE, SIZE>;
 
  StorageType storage{}; 
  std::unique_ptr<StorageType> prev_storage{}; 
 
  void StoreValue(uint pos, int32_t 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);
    } else if (!this->prev_storage) {
      this->prev_storage = std::make_unique<StorageType>(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() override
  {
    if (this->prev_storage) {
      this->storage = *this->prev_storage;
      this->prev_storage.reset();
    }
  }
};
 
 
template <typename TYPE, uint SIZE>
struct TemporaryStorageArray {
  using StorageType = std::array<TYPE, SIZE>;
  using StorageInitType = std::array<uint16_t, SIZE>;
 
  StorageType storage{}; 
  StorageInitType init{}; 
  uint16_t init_key = 1; 
 
  void StoreValue(uint pos, int32_t 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 */
      this->init = {};
      this->init_key = 1;
    }
  }
};
 
void AddChangedPersistentStorage(BasePersistentStorageArray *storage);
 
typedef PersistentStorageArray<int32_t, 16> OldPersistentStorage;
 
using PersistentStorageID = PoolID<uint32_t, struct PersistentStorageIDTag, 0xFF000, 0xFFFFF>;
 
struct PersistentStorage;
using PersistentStoragePool = Pool<PersistentStorage, PersistentStorageID, 1>;
 
extern PersistentStoragePool _persistent_storage_pool;
 
struct PersistentStorage : PersistentStorageArray<int32_t, 256>, PersistentStoragePool::PoolItem<&_persistent_storage_pool> {
  PersistentStorage(const uint32_t new_grfid, uint8_t feature, TileIndex tile)
  {
    this->grfid = new_grfid;
    this->feature = feature;
    this->tile = tile;
  }
};
 
static_assert(std::tuple_size_v<decltype(OldPersistentStorage::storage)> <= std::tuple_size_v<decltype(PersistentStorage::storage)>);
 
#endif /* NEWGRF_STORAGE_H */