tahoma2d/toonz/sources/include/tcg/containers_reader.h

#pragma once

#ifndef TCG_CONTAINERS_READER_H
#define TCG_CONTAINERS_READER_H

// STD includes
#include <stack>

namespace tcg
{

//******************************************************************************
//    Generic Reader declaration
//******************************************************************************

template <typename Val>
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, typename Val = typename Container::value_type>
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, typename Val = typename Container::value_type>
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, typename ReaderType, typename Val = typename ReaderType::value_type>
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;

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