From 9db3cde73af598852da13b748eef31a8207cfcf2 Mon Sep 17 00:00:00 2001
From: frosch <frosch@openttd.org>
Date: Mon, 31 May 2010 20:22:57 +0000
Subject: (svn r19914) -Codechange: Wrap a helper class around temporary
 assignments of _current_company to ensure proper restoration.

---
 src/core/backup_type.hpp | 134 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 src/core/backup_type.hpp

(limited to 'src/core/backup_type.hpp')

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 */
-- 
cgit v1.2.3-54-g00ecf