#pragma once

#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 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;</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