// Copyright (C) 2014-2015 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of Nova libraries. 
// For conditions of distribution and use, see copying.txt file in root folder.

/**
 * @file any.hh
 * @author Kornel Kisielewicz
 * @brief any type
 *
 * based on http://www.two-sdg.demon.co.uk/curbralan/papers/ValuedConversions.pdf
 */

#ifndef NV_STL_ANY_HH
#define NV_STL_ANY_HH

#include <nv/common.hh>
#include <nv/stl/utility.hh>
#include <nv/stl/type_traits.hh>
#include <nv/stl/type_info.hh>

#error "any type is currently unsupported!"

namespace nv
{
	
	class any
	{
	public:
		any() : m_content( nullptr ) {}
		
		any( const any& other )
			: m_content( other.m_content ? other.m_content->clone() : nullptr )
		{}

		template< typename T >
		any( const T& value )
			: m_content( new holder<T>( value ) )
		{}

		any( any&& other ) 
			: m_content( other.m_content )
		{}

		template< typename T >
		any( T&& value )
			: m_content( new holder<T>( forward<T>(value) ) )
		{}

		~any() 
		{ 
			delete m_content; 
		}

		any& swap( any& rhs )
		{
			nv::swap( m_content, rhs.m_content );
			return *this;
		}

		any& operator=( const any& rhs )
		{
			return swap( any( rhs ) );
		}

		any& operator=( any&& rhs )
		{
			swap( rhs );
			any().swap( rhs );
			return *this;
		}

		template < typename T >
		any& operator= ( T&& rhs )
		{
			any( forward<T>(rhs) ).swap(*this);
			return *this;
		}

		operator const void* () const
		{
			return m_content;
		}

		template< typename T >
		bool copy_to( T& value ) const
		{
			const T* copyable = to_ptr<T>();
			if ( copyable ) value = *copyable;
			return copyable;
		}
		template< typename T >
		const T* to_ptr() const
		{
			return type_info() == typeid(T) ? &static_cast< holder<T> *>(m_content)->held				: nullptr;
		}

		bool empty() const
		{
			return !m_content;
		}

		void clear()
		{
			any().swap(*this);
		}

		const std::type_info &type_info() const
		{
			return m_content ? m_content->type_info() : typeid(void);
		}
	private:
		class placeholder
		{
		public:
			virtual const std::type_info& type_info() const = 0;
			virtual placeholder *clone() const = 0;
			virtual ~placeholder() {}
		};

		template< typename T >
		class holder : public placeholder
		{
		public:
			holder( const T& value ) : held(value)
			{
			}
			holder( T&& value ) : held(forward<T>(value))
			{
			}
			virtual const std::type_info &type_info() const
			{
				return typeid(T);
			}
			virtual placeholder *clone() const
			{
				return new holder(held);
			}
			const T held;
		};
		placeholder *m_content;
	};

	inline void swap( any& lhs, any& rhs )
	{
		lhs.swap(rhs);
	}

	template< typename T >
	T any_cast( const any& operand )
	{
		const T* result = operand.to_ptr<T>();
		return result ? *result : throw std::bad_cast();
	}
}

#endif // NV_STL_ANY_HH