////////////////////////////////////////////////////////////////////////////////////////////////////
// TailoredAny.h

#pragma once

#include <algorithm>
#include <Loki/EmptyType.h>
#include <Loki/TypeInfo.h>

struct RttiTypeInfoStrategy
{
	typedef Loki::TypeInfo TypeInfo;
	
	template<typename T>
		static TypeInfo Identify() { return typeid(T); }

	template<typename T>
		static TypeInfo Identify(const T& t) { return typeid(t); }
};

template<class NewStrategy_ = Loki::EmptyType, class TypeInfoStrategy_ = RttiTypeInfoStrategy>
class TailoredAny
{
public:
	typedef TypeInfoStrategy_ TypeInfoStrategy;
	typedef typename TypeInfoStrategy_::TypeInfo TypeInfo;

	TailoredAny()
		:	content_(0)
	{}

	template<class ValueType_>
        TailoredAny(const ValueType_& value)
		:	content_(new Holder_<ValueType_>(value))
	{}

	TailoredAny(const TailoredAny& other)
		:	content_(other.content_ ? other.content_->Clone() : 0)
	{}

	~TailoredAny() { delete content_; }

	template<class ValueType_>
		TailoredAny& operator=(const ValueType_& value)
	{
		TailoredAny(value).Swap(*this);
		return *this;
	}

	TailoredAny& operator=(const TailoredAny& other)
	{
		TailoredAny(other).Swap(*this);
		return *this;
	}

	void Swap(TailoredAny& other)
	{
		std::swap(content_, other.content_);
	}

	bool Empty() const { return !content_; }

	TypeInfo Type() const
	{
		return content_ ? content->Type() : TypeInfoStrategy_::Identify<void>();
	}

private:
	struct PlaceHolder_ : NewStrategy_
	{
		virtual TypeInfo Type() const = 0;
		virtual PlaceHolder_* Clone() const = 0;
		virtual ~PlaceHolder_() {}
	};

	template<class ValueType_>
	struct Holder_ : PlaceHolder_
	{
		Holder_(const ValueType_& value)
			:	held_(value)
		{}
		
		TypeInfo Type() const
		{
			return TypeInfoStrategy_::Identify(held_);;
		}

		PlaceHolder_* Clone() const
		{
			return new Holder_(held_);
		}

		ValueType_ held_;
	};

	template<class ValueType_, class S1_, class S2_>
		friend ValueType_* TailoredAnyCast(TailoredAny<S1_, S2_>*);

	PlaceHolder_* content_;
};

////////////////////////////////////////////////////////////////////////////////////////////////////

template<class ValueType_, class S1_, class S2_>
ValueType_* TailoredAnyCast(TailoredAny<S1_, S2_>* operand)
{
	typedef TailoredAny<S1_, S2_>::TypeInfoStrategy TypeInfoStrategy;
	return operand && operand->Type() == TypeInfoStrategy::Identify<ValueType_>()
		?	&static_cast<TailoredAny<S1_, S2_>::Holder_<ValueType_>*>(operand->content_)->held_
		:	0;
}

template<class ValueType_, class S1_, class S2_>
const ValueType_* TailoredAnyCast(const TailoredAny<S1_, S2_>* operand)
{
	return TailoredAnyCast<ValueType_, S1_>(const_cast<TailoredAny<S1_, S2_>*>(operand));
}

template<class ValueType_, class S1_, class S2_>
ValueType_ TailoredAnyCast(const TailoredAny<S1_, S2_>& operand)
{
	const ValueType_* result = TailoredAnyCast<ValueType_>(&operand);
	if(!result)
		throw std::bad_cast();
	return *result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////