#ifndef XMLSTORAGE_H
#define XMLSTORAGE_H

#include "sourceObject.h"
#include "xmlObjectLoader.h"
#include "exceptions.h"
#include <set>
#include <list>
#include <map>
#include <boost/intrusive_ptr.hpp>

SimpleMessageException(StoreFailed);

#define SINGLE(X) \
	boost::intrusive_ptr<X>
#define STORAGEOF(X) \
	std::map<std::string, boost::intrusive_ptr<X> >
#define ANONORDEREDSTORAGEOF(X) \
	std::list<boost::intrusive_ptr<X> >
#define ANONSTORAGEOF(X) \
	std::set<boost::intrusive_ptr<X> >

class Storer;
typedef boost::intrusive_ptr<Storer> StorerPtr;
class Storer : public virtual IntrusivePtrBase {
	public:
		template <class L, class X>
		static StorerPtr into(SINGLE(X) * obj);
		template <class L, class X>
		static StorerPtr into(STORAGEOF(X) * map);
		template <class L, class X>
		static StorerPtr into(ANONSTORAGEOF(X) * set);
		template <class L, class X>
		static StorerPtr into(ANONORDEREDSTORAGEOF(X) * list);

		virtual boost::intrusive_ptr<IntrusivePtrBase> save(const xmlpp::Element *) = 0;
};

template <class X, class M, class L>
class StorerBase : public Storer {
	public:
		typedef M * Map;
		boost::intrusive_ptr<IntrusivePtrBase> save(const xmlpp::Element * p) {
			try {
				boost::intrusive_ptr<X> O = boost::dynamic_pointer_cast<X>(
						LoaderBase::getLoader<L, NotSupported>(p->get_name())->createFrom(p));
				if (O) {
					if (!insert(p, O)) {
						throw StoreFailed(p->get_attribute_value("name"));
					}
				}
				return O;
			}
			catch (NotSupported) {
				return NULL;
			}
		}
		virtual bool insert(const xmlpp::Element *, boost::intrusive_ptr<X>) = 0;
};

template <class X, class M, class L>
class StorerImpl : public StorerBase<X, M, L> {
	public:
		StorerImpl(M * m);
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O);
};
template <class X, class L>
class StorerImpl<X, SINGLE(X), L> : public StorerBase<X, SINGLE(X), L> {
	public:
		typedef SINGLE(X) Obj;
		StorerImpl(SINGLE(X) * o) : obj(o)
		{
		}
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O)
		{
			*obj = O;
			return true;
		}
		Obj * obj;
};
template <class X, class L>
class StorerImpl<X, STORAGEOF(X), L> : public StorerBase<X, STORAGEOF(X), L> {
	public:
		typedef STORAGEOF(X) Map;
		StorerImpl(STORAGEOF(X) * m) : map(m)
		{
		}
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O)
		{
			return map->insert(typename Map::value_type(O->name, O)).second;
		}
		Map * map;
};
template <class X, class L>
class StorerImpl<X, ANONSTORAGEOF(X), L> : public StorerBase<X, ANONSTORAGEOF(X), L> {
	public:
		typedef ANONSTORAGEOF(X) Map;
		StorerImpl(ANONSTORAGEOF(X) * m) : map(m)
		{
		}
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O)
		{
			map->insert(O);
			return true;
		}
		Map * map;
};
template <class X, class L>
class StorerImpl<X, ANONORDEREDSTORAGEOF(X), L> : public StorerBase<X, ANONORDEREDSTORAGEOF(X), L> {
	public:
		typedef ANONORDEREDSTORAGEOF(X) Map;
		StorerImpl(ANONORDEREDSTORAGEOF(X) * m) : map(m)
		{
		}
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O)
		{
			map->push_back(O);
			return true;
		}
		Map * map;
};

template <class L, class X>
StorerPtr
Storer::into(SINGLE(X) * obj) {
	return new StorerImpl<X, SINGLE(X), L>(obj);
}

template <class L, class X>
StorerPtr
Storer::into(STORAGEOF(X) * map) {
	return new StorerImpl<X, STORAGEOF(X), L>(map);
}

template <class L, class X>
StorerPtr
Storer::into(ANONSTORAGEOF(X) * set) {
	return new StorerImpl<X, ANONSTORAGEOF(X), L>(set);
}

template <class L, class X>
StorerPtr
Storer::into(ANONORDEREDSTORAGEOF(X) * list) {
	return new StorerImpl<X, ANONORDEREDSTORAGEOF(X), L>(list);
}

#endif