move support: optional class template

sprout/optional/make_optional.hpp

@@ -1,22 +1,24 @@
 #ifndef SPROUT_OPTIONAL_MAKE_OPTIONAL_HPP
 #define SPROUT_OPTIONAL_MAKE_OPTIONAL_HPP
 
+#include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/optional/optional.hpp>
+#include <sprout/utility/forward.hpp>
 
 namespace sprout {
 	//
 	// make_optional
 	//
 	template<typename T>
-	inline SPROUT_CONSTEXPR sprout::optional<T>
+	inline SPROUT_CONSTEXPR sprout::optional<typename std::decay<T>::type>
-	make_optional(T const& v) {
+	make_optional(T&& v) {
-		return optional<T>(v);
+		return sprout::optional<typename std::decay<T>::type>(sprout::forward<T>(v));
 	}
 	template<typename T>
-	inline SPROUT_CONSTEXPR sprout::optional<T>
+	inline SPROUT_CONSTEXPR sprout::optional<typename std::decay<T>::type>
-	make_optional(bool cond, T const& v) {
+	make_optional(bool cond, T&& v) {
-		return optional<T>(cond, v);
+		return sprout::optional<typename std::decay<T>::type>(cond, sprout::forward<T>(v));
 	}
 }	// namespace sprout
 

sprout/optional/optional.hpp

@@ -4,6 +4,8 @@
 #include <sprout/config.hpp>
 #include <sprout/utility/value_holder/value_holder.hpp>
 #include <sprout/utility/swap.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/utility/move.hpp>
 #include <sprout/none.hpp>
 #include <sprout/optional/nullopt.hpp>
 #include <sprout/optional/exceptions.hpp>
@@ -30,6 +32,7 @@ namespace sprout {
 		typedef typename holder_type::pointer_type pointer_type;
 		typedef typename holder_type::pointer_const_type pointer_const_type;
 		typedef typename holder_type::argument_type argument_type;
+		typedef typename holder_type::movable_argument_type movable_argument_type;
 	private:
 		bool init;
 		holder_type val;
@@ -38,43 +41,63 @@ namespace sprout {
 			init = false;
 		}
 	public:
-		// 20.5.4.1, constructors
+		// 20.6.4.1, constructors
 		SPROUT_CONSTEXPR optional() SPROUT_NOEXCEPT
 			: init(false)
 		{}
 		SPROUT_CONSTEXPR optional(sprout::nullopt_t) SPROUT_NOEXCEPT
 			: init(false)
 		{}
-		SPROUT_CONSTEXPR optional(argument_type v)
-			: init(true)
-			, val(v)
-		{}
-		SPROUT_CONSTEXPR optional(bool cond, argument_type v)
-			: init(cond)
-			, val(cond ? holder_type(v) : holder_type())
-		{}
 		SPROUT_CONSTEXPR optional(optional const& v)
 			: init(v.init)
 			, val(v.is_initialized() ? holder_type(*v) : holder_type())
 		{}
+		SPROUT_CONSTEXPR optional(optional&& v)
+			: init(v.init)
+			, val(v.is_initialized() ? holder_type(sprout::move(*v)) : holder_type())
+		{}
+		SPROUT_CONSTEXPR optional(T const& v)
+			: init(true)
+			, val(v)
+		{}
+		SPROUT_CONSTEXPR optional(T&& v)
+			: init(true)
+			, val(sprout::move(v))
+		{}
+		SPROUT_CONSTEXPR optional(bool cond, T const& v)
+			: init(cond)
+			, val(cond ? holder_type(v) : holder_type())
+		{}
+		SPROUT_CONSTEXPR optional(bool cond, T&& v)
+			: init(cond)
+			, val(cond ? holder_type(sprout::move(v)) : holder_type())
+		{}
 		template<typename U>
 		explicit SPROUT_CONSTEXPR optional(optional<U> const& v)
 			: init(v.is_initialized())
 			, val(v.is_initialized() ? holder_type(*v) : holder_type())
 		{}
-		// 20.5.4.3, assignment
+		// 20.6.4.3, assignment
 		optional& operator=(sprout::nullopt_t v) SPROUT_NOEXCEPT {
 			assign(v);
 			return *this;
 		}
-		optional& operator=(argument_type v) {
-			assign(v);
-			return *this;
-		}
 		optional& operator=(optional const& v) {
 			assign(v);
 			return *this;
 		}
+		optional& operator=(optional&& v) {
+			assign(sprout::forward<optional>(v));
+			return *this;
+		}
+		optional& operator=(T const& v) {
+			assign(v);
+			return *this;
+		}
+		optional& operator=(T&& v) {
+			assign(sprout::forward<T>(v));
+			return *this;
+		}
 		template<typename U>
 		optional& operator=(optional<U> const& v) {
 			assign(v);
@@ -84,14 +107,22 @@ namespace sprout {
 		void assign(sprout::nullopt_t) SPROUT_NOEXCEPT {
 			destroy();
 		}
-		void assign(argument_type v) {
+		void assign(optional const& v) {
 			optional temp(v);
 			temp.swap(*this);
 		}
-		void assign(optional const& v) {
+		void assign(optional&& v) {
+			optional temp(sprout::forward<optional>(v));
+			temp.swap(*this);
+		}
+		void assign(T const& v) {
 			optional temp(v);
 			temp.swap(*this);
 		}
+		void assign(T&& v) {
+			optional temp(sprout::forward<T>(v));
+			temp.swap(*this);
+		}
 		template<typename U>
 		void assign(optional<U> const& v) {
 			optional temp(v);
@@ -104,61 +135,20 @@ namespace sprout {
 		void reset(sprout::nullopt_t v) SPROUT_NOEXCEPT {
 			assign(v);
 		}
-		void reset(argument_type v) {
+		void reset(T const& v) {
 			assign(v);
 		}
-		// 20.5.4.4, swap
+		void reset(T&& v) {
+			assign(sprout::forward<T>(v));
+		}
+		// 20.6.4.4, swap
 		void swap(optional& other)
 		SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(val, other.val)))
 		{
 			sprout::swap(init, other.init);
 			sprout::swap(val, other.val);
 		}
-		// 20.5.4.5, observers
+		// 20.6.4.5, observers
-		SPROUT_CONSTEXPR reference_const_type operator*() const {
-			return (SPROUT_ASSERT(is_initialized()), true) ? val.get()
-				: val.get()
-				;
-		}
-		reference_type operator*() {
-			return (SPROUT_ASSERT(is_initialized()), true) ? val.get()
-				: val.get()
-				;
-		}
-		SPROUT_CONSTEXPR reference_const_type get() const {
-			return is_initialized() ? val.get()
-				: (throw sprout::bad_optional_access("optional<>: bad optional access"), val.get())
-				;
-		}
-		reference_type get() {
-			return is_initialized() ? val.get()
-				: (throw sprout::bad_optional_access("optional<>: bad optional access"), val.get())
-				;
-		}
-		SPROUT_CONSTEXPR reference_const_type get_value_or(reference_const_type& v) const {
-			return is_initialized() ? val.get()
-				: v
-				;
-		}
-		reference_type get_value_or(reference_type& v) {
-			return is_initialized() ? val.get()
-				: v
-				;
-		}
-
-		SPROUT_CONSTEXPR reference_const_type value() const {
-			return get();
-		}
-		reference_type value() {
-			return get();
-		}
-		SPROUT_CONSTEXPR reference_const_type value_or(reference_const_type& v) const {
-			return get_value_or(v);
-		}
-		reference_type value_or(reference_type& v) {
-			return get_value_or(v);
-		}
-
 		SPROUT_CONSTEXPR pointer_const_type operator->() const {
 			return SPROUT_ASSERT(is_initialized()),
 				val.get_pointer()
@@ -186,6 +176,50 @@ namespace sprout {
 			return get_pointer();
 		}
 
+		SPROUT_CONSTEXPR reference_const_type operator*() const {
+			return (SPROUT_ASSERT(is_initialized()), true) ? val.get()
+				: val.get()
+				;
+		}
+		reference_type operator*() {
+			return (SPROUT_ASSERT(is_initialized()), true) ? val.get()
+				: val.get()
+				;
+		}
+		SPROUT_CONSTEXPR reference_const_type value() const {
+			return get();
+		}
+		reference_type value() {
+			return get();
+		}
+		SPROUT_CONSTEXPR reference_const_type get() const {
+			return is_initialized() ? val.get()
+				: (throw sprout::bad_optional_access("optional<>: bad optional access"), val.get())
+				;
+		}
+		reference_type get() {
+			return is_initialized() ? val.get()
+				: (throw sprout::bad_optional_access("optional<>: bad optional access"), val.get())
+				;
+		}
+
+		SPROUT_CONSTEXPR reference_const_type value_or(reference_const_type& v) const {
+			return get_value_or(v);
+		}
+		reference_type value_or(reference_type& v) {
+			return get_value_or(v);
+		}
+		SPROUT_CONSTEXPR reference_const_type get_value_or(reference_const_type& v) const {
+			return is_initialized() ? val.get()
+				: v
+				;
+		}
+		reference_type get_value_or(reference_type& v) {
+			return is_initialized() ? val.get()
+				: v
+				;
+		}
+
 		SPROUT_CONSTEXPR operator bool() const SPROUT_NOEXCEPT {
 			return is_initialized();
 		}

sprout/utility/value_holder/value_holder.hpp

@@ -3,6 +3,7 @@
 
 #include <sprout/config.hpp>
 #include <sprout/utility/swap.hpp>
+#include <sprout/utility/move.hpp>
 
 namespace sprout {
 	namespace detail {
@@ -17,11 +18,15 @@ namespace sprout {
 			typedef T const* const_pointer;
 			typedef T const* mutable_or_const_pointer;
 			typedef T const& param_type;
+			typedef T&& movable_param_type;
 			typedef T holder_type;
 		public:
 			static SPROUT_CONSTEXPR holder_type const& hold(param_type p) SPROUT_NOEXCEPT {
 				return p;
 			}
+			static SPROUT_CONSTEXPR holder_type&& hold(movable_param_type p) SPROUT_NOEXCEPT {
+				return sprout::move(p);
+			}
 			static SPROUT_CONSTEXPR reference ref(holder_type& r) {
 				return r;
 			}
@@ -46,10 +51,14 @@ namespace sprout {
 			typedef T const* const_pointer;
 			typedef T const* mutable_or_const_pointer;
 			typedef T const& param_type;
+			typedef T const&& movable_param_type;
 			typedef T holder_type;
 		public:
 			static SPROUT_CONSTEXPR holder_type const& hold(param_type p) SPROUT_NOEXCEPT {
-				return &p;
+				return p;
+			}
+			static SPROUT_CONSTEXPR holder_type const&& hold(movable_param_type p) SPROUT_NOEXCEPT {
+				return sprout::move(p);
 			}
 			static SPROUT_CONSTEXPR reference ref(holder_type& r) {
 				return *r;
@@ -75,6 +84,7 @@ namespace sprout {
 			typedef T const* const_pointer;
 			typedef T* mutable_or_const_pointer;
 			typedef T& param_type;
+			typedef T&& movable_param_type;
 			typedef T* holder_type;
 		public:
 			static SPROUT_CONSTEXPR holder_type hold(param_type p) SPROUT_NOEXCEPT {
@@ -98,6 +108,7 @@ namespace sprout {
 			typedef T const* const_pointer;
 			typedef T const* mutable_or_const_pointer;
 			typedef T const& param_type;
+			typedef T const&& movable_param_type;
 			typedef T const* holder_type;
 		public:
 			static SPROUT_CONSTEXPR holder_type hold(param_type p) SPROUT_NOEXCEPT {
@@ -130,11 +141,13 @@ namespace sprout {
 		typedef typename helper_type::const_pointer const_pointer;
 		typedef typename helper_type::mutable_or_const_pointer mutable_or_const_pointer;
 		typedef typename helper_type::param_type param_type;
+		typedef typename helper_type::movable_param_type movable_param_type;
 		typedef reference reference_type;
 		typedef mutable_or_const_reference reference_const_type;
 		typedef pointer pointer_type;
 		typedef mutable_or_const_pointer pointer_const_type;
 		typedef param_type argument_type;
+		typedef movable_param_type movable_argument_type;
 	private:
 		holder_type holder_;
 	public:
@@ -142,13 +155,23 @@ namespace sprout {
 			: holder_()
 		{}
 		SPROUT_CONSTEXPR value_holder(value_holder const&) = default;
+		SPROUT_CONSTEXPR value_holder(value_holder&&) = default;
 		explicit SPROUT_CONSTEXPR value_holder(param_type p)
 			: holder_(helper_type::hold(p))
 		{}
+		explicit SPROUT_CONSTEXPR value_holder(movable_argument_type p)
+			: holder_(helper_type::hold(sprout::move(p)))
+		{}
 
 		value_holder& operator=(value_holder const&) = default;
+		value_holder& operator=(value_holder&&) = default;
 		value_holder& operator=(param_type p) {
-			value_holder temp(p);
+			value_holder temp(helper_type::hold(p));
+			temp.swap(p);
+			return *this;
+		}
+		value_holder& operator=(movable_argument_type p) {
+			value_holder temp(helper_type::hold(sprout::move(p)));
 			temp.swap(p);
 			return *this;
 		}