optional.h

/*
 *
 * (C) Copyright Sarfaraz Nawaz 2013-14, sir_nawaz959@yahoo.com
 *
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt Or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 */

#pragma once

#include <stdexcept>
#include <type_traits>
#include <utility>

#include "alias.h"


namespace foam
{
	
	static const struct none_t {} none;

	template<typename T>
	class optional
	{
		public:
			typedef T value_type;
			typedef alias::aligned_storage<T> storage_type;

			optional() : _valid(false) {}

			template<typename U>
			optional(U && value) :  _valid(true) 
			{
				new (&_storage) T(static_cast<T>(std::forward<U>(value)));
			}

			~optional()
			{
				if ( has_value() )  value().~T();
			}

			optional(optional const & other) : _valid(other._valid) 
			{
				if ( _valid )
				{
					copy(*this, other);
				}
			}

			optional(optional && other) : _valid(other._valid) 
			{
				if ( _valid )
				{
					move(*this, other);
				}
			}
			
			optional& operator=(none_t const &)
			{
				if ( has_value() )
				{
					value().~T();
				}
				_valid = false;
				return *this;
			}
		
	
			template<typename U>
			optional& operator=(U && other)
			{
				return *this = optional(std::forward<U>(other));
			}

			optional& operator=(optional const & other) 
			{
				if ( has_value() )
				{
					value().~T();
				}
				_valid = other._valid;
				if ( _valid )
				{
					copy(*this, other);
				}
				return *this;
			}

			optional& operator=(optional && other)
			{
				if ( has_value() )
				{
					value().~T();
				}
				_valid = other._valid;
				if ( _valid )
				{
					move(*this, other);
				}
				return *this;
			}

			bool has_value() const { return _valid; }

			explicit operator bool() const { return has_value(); }

			T & value()
			{ 
				return const_cast<T&>(static_cast<optional<T> const &>(*this).value());
			}

			T const & value() const 
			{ 
				if ( !has_value() )
				{
					throw std::logic_error("optional<T> doesn't have value.");
				}
				return *reinterpret_cast<T const*>(&_storage);
			}
		
			T& operator*() { return value(); }
			T const & operator*() const { return value(); }

			bool operator==(optional const & other) const
			{
				if ( has_value() && other.has_value() )
				       return value() == other.value();
				return !has_value() && !other.has_value();
			}

			bool operator!=(optional const & other) const
			{
				return !(*this == other);
			}

			bool operator == (none_t const &) const
			{
				return !has_value();
			}
			bool operator != (none_t const &) const
			{
				return !(*this == none);
			}

		private:

			void copy(optional<T> & dst, optional<T> const & src) const
			{
				new (&dst._storage) T(src.value());
			}

			void move(optional<T> & dst, optional<T> const & src) const
			{
				new (&dst._storage) T(std::move(const_cast<T&>(src.value())));
			}

		private:

			bool _valid;

			storage_type _storage;
	};
}