#ifndef XMLSTORAGE_H
#define XMLSTORAGE_H

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

SimpleMessageException(StoreFailed);

#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 X>
		static StorerPtr into(STORAGEOF(X) * map);
		template <class X>
		static StorerPtr into(ANONSTORAGEOF(X) * set);
		template <class X>
		static StorerPtr into(ANONORDEREDSTORAGEOF(X) * list);

		virtual bool save(SourceObjectPtr o, const xmlpp::Element *) = 0;
};

template <class X, class M = STORAGEOF(X)>
class StorerBase : public Storer {
	public:
		typedef M * Map;
		bool save(SourceObjectPtr obj, const xmlpp::Element * p) {
			boost::intrusive_ptr<X> O = boost::dynamic_pointer_cast<X>(obj);
			if (O) {
				if (insert(p, O)) {
					return true;
				}
				throw StoreFailed(obj->name);
			}
			return false;
		}
		virtual bool insert(const xmlpp::Element *, boost::intrusive_ptr<X>) = 0;
};

template <class X, class M = STORAGEOF(X)>
class StorerImpl : public StorerBase<X, M> {
	public:
		StorerImpl(M * m);
		bool insert(const xmlpp::Element *, boost::intrusive_ptr<X> O);
};
template <class X>
class StorerImpl<X, STORAGEOF(X)> : public StorerBase<X, STORAGEOF(X)> {
	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 StorerImpl<X, ANONSTORAGEOF(X)> : public StorerBase<X, ANONSTORAGEOF(X)> {
	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 StorerImpl<X, ANONORDEREDSTORAGEOF(X)> : public StorerBase<X, ANONORDEREDSTORAGEOF(X)> {
	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 X>
StorerPtr
Storer::into(STORAGEOF(X) * map) {
	return new StorerImpl<X, STORAGEOF(X)>(map);
}

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

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

#endif