Files
@ r21103:927c66dfabe2
Branch filter:
Location: cpp/openttd-patchpack/source/src/core/backup_type.hpp
r21103:927c66dfabe2
4.0 KiB
text/x-c++hdr
(svn r26188) -Codechange: Move station refitting to a separate function.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | /* $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 backup_type.hpp Class for backupping variables and making sure they are restored later. */
#ifndef BACKUP_TYPE_HPP
#define BACKUP_TYPE_HPP
#include "../debug.h"
/**
* Class to backup a specific variable and restore it later.
* The variable is not restored automatically, but assertions make sure it is restored.
* You have to call either Trash() or Restore() exactly once.
*/
template <typename T>
struct Backup {
/**
* Backup variable.
* @param original Variable to backup.
* @param file Filename for debug output. Use FILE_LINE macro.
* @param line Linenumber for debug output. Use FILE_LINE macro.
*/
Backup(T &original, const char * const file, const int line) : original(original), valid(true), original_value(original), file(file), line(line) {}
/**
* Backup variable and switch to new value.
* @param original Variable to backup.
* @param new_value New value for variable.
* @param file Filename for debug output. Use FILE_LINE macro.
* @param line Linenumber for debug output. Use FILE_LINE macro.
*/
template <typename U>
Backup(T &original, const U &new_value, const char * const file, const int line) : original(original), valid(true), original_value(original), file(file), line(line)
{
/* Note: We use a separate typename U, so type conversions are handled by assignment operator. */
original = new_value;
}
/**
* Check whether the variable was restored on object destruction.
*/
~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, "%s:%d: Backupped value was not restored!", this->file, this->line);
this->Restore();
}
}
/**
* Checks whether the variable was already restored.
* @return true if variable has already been restored.
*/
bool IsValid() const
{
return this->valid;
}
/**
* Returns the backupped value.
* @return value from the backup.
*/
const T &GetOriginalValue() const
{
assert(this->valid);
return original_value;
}
/**
* Change the value of the variable.
* While this does not touch the backup at all, it ensures that the variable is only modified while backupped.
* @param new_value New value for variable.
*/
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;
}
/**
* Revert the variable to its original value, but do not mark it as restored.
*/
void Revert()
{
assert(this->valid);
this->original = this->original_value;
}
/**
* Trash the backup. The variable shall not be restored anymore.
*/
void Trash()
{
assert(this->valid);
this->valid = false;
}
/**
* Restore the variable.
*/
void Restore()
{
this->Revert();
this->Trash();
}
/**
* Update the backup.
* That is trash the old value and make the current value of the variable the value to be restored later.
*/
void Update()
{
assert(this->valid);
this->original_value = this->original;
}
/**
* Check whether the variable is currently equals the backup.
* @return true if equal
*/
bool Verify() const
{
assert(this->valid);
return this->original_value == this->original;
}
private:
T &original;
bool valid;
T original_value;
const char * const file;
const int line;
};
#endif /* BACKUP_TYPE_HPP */
|