New utility for managing volatile class members

Fixes #1025

os/include/util/volatile_object.h

@@ -0,0 +1,167 @@
+/*
+ * \brief  Utility for manual in-place construction of objects
+ * \author Norman Feske
+ * \date   2014-01-10
+ */
+
+/*
+ * Copyright (C) 2014 Genode Labs GmbH
+ *
+ * This file is part of the Genode OS framework, which is distributed
+ * under the terms of the GNU General Public License version 2.
+ */
+
+#ifndef _INCLUDE__UTIL__VOLATILE_OBJECT_H_
+#define _INCLUDE__UTIL__VOLATILE_OBJECT_H_
+
+#include <base/printf.h>
+#include <base/stdint.h>
+
+namespace Genode {
+	template<typename> class Volatile_object;
+	template<typename> class Lazy_volatile_object;
+}
+
+
+/**
+ * Place holder for an object to be repeatedly constructed and destructed
+ *
+ * This class template acts as a smart pointer that refers to an object
+ * contained within the smart pointer itself. The contained object may be
+ * repeatedly constructed and destructed while staying in the same place. This
+ * is useful for replacing aggregated members during the lifetime of a compound
+ * object.
+ *
+ * \param  MT type
+ */
+template <typename MT>
+class Genode::Volatile_object
+{
+	private:
+
+		/**
+		 * Utility to equip an existing type 'T' with a placement new operator
+		 */
+		template <typename T>
+		struct Placeable : T
+		{
+			template <typename... ARGS>
+			Placeable(ARGS &&... args)
+			:
+				T(args...)
+			{ }
+
+			void *operator new (size_t, void *ptr) { return ptr; }
+		};
+
+		/**
+		 * Static reservation of memory for the embedded object
+		 */
+		char _space[sizeof(MT)];
+
+		/**
+		 * True if the volatile object contains a constructed object
+		 */
+		bool _constructed = false;
+
+		template <typename... ARGS> void _do_construct(ARGS &&... args)
+		{
+			new (_space) Placeable<MT>(args...);
+			_constructed = true;
+		}
+
+		MT       *_ptr()             { return reinterpret_cast<MT       *>(_space); }
+		MT const *_const_ptr() const { return reinterpret_cast<MT const *>(_space); }
+
+		void _check_constructed() const
+		{
+			if (!_constructed)
+				throw Deref_unconstructed_object();
+		}
+
+	protected:
+
+		/**
+		 * Dummy type used as a hook for 'Lazy_volatile_object' to bypass the
+		 * default constructor by invoking the 'Volatile_object(Lazy *)'
+		 * constructor.
+		 */
+		struct Lazy { };
+
+		/**
+		 * Constructor that omits the initial construction of the object
+		 */
+		Volatile_object(Lazy *) { }
+
+	public:
+
+		class Deref_unconstructed_object { };
+
+		/**
+		 * Constructor
+		 *
+		 * The arguments are forwarded to the constructor of the embedded
+		 * object.
+		 */
+		template <typename... ARGS>
+		Volatile_object(ARGS &&... args)
+		{
+			_do_construct(args...);
+		}
+
+		~Volatile_object() { destruct(); }
+
+		/**
+		 * Construct new object in place
+		 *
+		 * If the 'Volatile_object' already hosts a constructed object, the old
+		 * object will be destructed first.
+		 */
+		template <typename... ARGS>
+		void construct(ARGS &&... args)
+		{
+			destruct();
+			_do_construct(args...);
+		}
+
+		/**
+		 * Destruct object
+		 */
+		void destruct()
+		{
+			if (!_constructed)
+				return;
+
+			/* invoke destructor */
+			_ptr()->~MT();
+
+			_constructed = false;
+		}
+
+		/**
+		 * Return true of volatile object contains a constructed object
+		 */
+		bool is_constructed() const { return _constructed; }
+
+		/**
+		 * Access contained object
+		 */
+		MT       *operator -> ()       { _check_constructed(); return       _ptr(); }
+		MT const *operator -> () const { _check_constructed(); return _const_ptr(); }
+};
+
+
+/**
+ * Volatile object that holds no initially constructed object
+ */
+template <typename MT>
+struct Genode::Lazy_volatile_object : Volatile_object<MT>
+{
+	template <typename... ARGS>
+	Lazy_volatile_object(ARGS... args)
+	:
+		Volatile_object<MT>((typename Volatile_object<MT>::Lazy *)0)
+	{ }
+};
+
+#endif /* _INCLUDE__UTIL__VOLATILE_OBJECT_H_ */