summaryrefslogtreecommitdiff
path: root/src/core
diff options
context:
space:
mode:
authorfrosch <frosch@openttd.org>2010-05-31 20:22:57 +0000
committerfrosch <frosch@openttd.org>2010-05-31 20:22:57 +0000
commit9db3cde73af598852da13b748eef31a8207cfcf2 (patch)
tree996d3e9c49ce7c3611a70ed4fa6f03774b4cafe9 /src/core
parent1d05fbebbef72722d400ab4f7693dde11205a7f4 (diff)
downloadopenttd-9db3cde73af598852da13b748eef31a8207cfcf2.tar.xz
(svn r19914) -Codechange: Wrap a helper class around temporary assignments of _current_company to ensure proper restoration.
Diffstat (limited to 'src/core')
-rw-r--r--src/core/backup_type.hpp134
1 files changed, 134 insertions, 0 deletions
diff --git a/src/core/backup_type.hpp b/src/core/backup_type.hpp
new file mode 100644
index 000000000..90b48c2a8
--- /dev/null
+++ b/src/core/backup_type.hpp
@@ -0,0 +1,134 @@
+/* $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
+
+/**
+ * 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.
+ */
+ Backup(T &original) : original(original), valid(true), original_value(original) {}
+
+ /**
+ * Backup variable and switch to new value.
+ * @param original Variable to backup.
+ * @param new_value New value for variable.
+ */
+ template <typename U>
+ Backup(T &original, const U &new_value) : original(original), valid(true), original_value(original)
+ {
+ /* 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 */
+ assert(!this->valid);
+ }
+
+ /**
+ * 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;
+};
+
+#endif /* BACKUP_TYPE_HPP */