#ifndef TCG_CONTAINERS_READER_H

#define TCG_CONTAINERS_READER_H

// STD includes

#include <stack></stack>

namespace tcg

{

//******************************************************************************

//    Generic Reader declaration

//******************************************************************************

template <typename val=""></typename>

class generic_containers_reader

{

public:

	typedef Val value_type;

public:

	virtual void openContainer() = 0;

	virtual void addElement(const value_type &value) = 0;

	virtual void closeContainer() = 0;

	// NOTE: Algorithms may require the openContainer() function to accept the

	// container's header data. Check the algorithms description if necessary.

};

//******************************************************************************

//    Some Actual Container Readers

//******************************************************************************

template <typename container,="" container::value_type="" typename="" val="typename"></typename>

class sequential_reader

{

	Container *m_values;

public:

	typedef Container container_type;

	typedef Val value_type;

public:

	sequential_reader(Container *container)

		: m_values(container) {}

	void openContainer() { m_values->clear(); }

	void addElement(const value_type &val) { m_values->push_back(val); }

	void closeContainer() {}

	const container_type *values() const { return m_values; }

	container_type *values() { return m_values; }

};

//------------------------------------------------------------------

template <typename container,="" container::value_type="" typename="" val="typename"></typename>

class ordered_reader

{

	Container *m_values;

public:

	typedef Container container_type;

	typedef Val value_type;

public:

	ordered_reader(Container &container)

		: m_values(container) {}

	void openContainer() { m_values->clear(); }

	void addElement(const value_type &val) { m_values->insert(val); }

	void closeContainer() {}

	const container_type *values() const { return m_values; }

	container_type *values() { return m_values; }

};

//------------------------------------------------------------------

template <typename container,="" readertype,="" readertype::value_type="" typename="" val="typename"></typename>

class multiple_reader

{

public:

	typedef Container container_type;

	typedef ReaderType reader_type;

	typedef Val value_type;

protected:

	Container *m_storage;

	std::stack<reader_type> m_stack;</reader_type>

public:

	multiple_reader(Container *storage)

		: m_storage(storage) {}

	reader_type &reader() { return m_stack.top(); }

	void openContainer() { m_stack.push(reader_type(new typename reader_type::container_type)); }

	void addElement(const value_type &val) { reader().addElement(val); }

	void closeContainer()

	{

		if (reader().values()->empty())

			delete reader().values();

		else

			m_storage->push_back(reader().values());

		m_stack.pop();

	}

	const container_type &storage() const { return m_storage; }

	container_type &storage() { return m_storage; }

};

} //namespace tcg

#endif //TCG_CONTAINERS_READER_H