backup_type.hpp

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 BACKUP_TYPE_HPP
#define BACKUP_TYPE_HPP
 
#include "../debug.h"
 
template <typename T>
struct Backup {
  Backup(T &original, const std::source_location location = std::source_location::current()) : original(original), valid(true), original_value(original), location(location) {}
 
  template <typename U>
  Backup(T &original, const U &new_value, const std::source_location location = std::source_location::current()) : original(original), valid(true), original_value(original), location(location)
  {
    /* Note: We use a separate typename U, so type conversions are handled by assignment operator. */
    original = new_value;
  }
 
  ~Backup()
  {
    /* Check whether restoration was done */
    if (this->valid)
    {
      /* We cannot assert here, as missing restoration is 'normal' when exceptions are thrown.
       * Exceptions are especially used to abort world generation. */
      Debug(misc, 0, "{}:{}: Backed-up value was not restored!", this->location.file_name(), this->location.line());
      this->Restore();
    }
  }
 
  bool IsValid() const
  {
    return this->valid;
  }
 
  const T &GetOriginalValue() const
  {
    assert(this->valid);
    return original_value;
  }
 
  template <typename U>
  void Change(const U &new_value)
  {
    /* Note: We use a separate typename U, so type conversions are handled by assignment operator. */
    assert(this->valid);
    original = new_value;
  }
 
  void Revert()
  {
    assert(this->valid);
    this->original = this->original_value;
  }
 
  void Trash()
  {
    assert(this->valid);
    this->valid = false;
  }
 
  void Restore()
  {
    this->Revert();
    this->Trash();
  }
 
  void Update()
  {
    assert(this->valid);
    this->original_value = this->original;
  }
 
  bool Verify() const
  {
    assert(this->valid);
    return this->original_value == this->original;
  }
 
private:
  T &original;
  bool valid;
  T original_value;
 
  const std::source_location location;
};
 
template <typename T>
struct AutoRestoreBackup {
  /*
   * There is explicitly no only original constructor version, as that would make it possible
   * for the new value to go out of scope before this object goes out of scope, thus defeating
   * the whole goal and reason for existing of this object.
   */
 
  AutoRestoreBackup(T &original, T new_value) : original(original), original_value(original)
  {
    original = new_value;
  }
 
  ~AutoRestoreBackup()
  {
    this->original = this->original_value;
  }
 
private:
  T &original;
  T original_value;
 
  /* Prevent copy, assignment and allocation on stack. */
  AutoRestoreBackup(const AutoRestoreBackup&) = delete;
  AutoRestoreBackup& operator=(AutoRestoreBackup&) = delete;
  static void *operator new(std::size_t) = delete;
  static void *operator new[](std::size_t) = delete;
};
 
#endif /* BACKUP_TYPE_HPP */