objiter.h

Go to the documentation of this file.

/*
Copyright (C) 2000  Jeffrey S. Freedman

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef INCL_OBJITER
#define INCL_OBJITER  1

#include "objlist.h"

class Map_chunk;
class Game_object;

/*
 *  Want to make all object iterators modification-safe.  For now, just
 *  trying to detect modification during iteration.
 */
template<class T>
class T_Safe_object_iterator
  {
  T_Object_list<T>& list;
public:
  T_Safe_object_iterator(T_Object_list<T>& l) : list(l)
    { list.add_iterator(); }
  ~T_Safe_object_iterator()
    { list.remove_iterator(); }
  };

/*
 *  Iterate through list of objects.
 */
template<class T>
class T_Object_iterator : public T_Safe_object_iterator<T>
  {
protected:
  T first;
  T stop;
  T cur;    // Next to return.
public:
  void reset()
    { cur = first; stop = 0; }
  T_Object_iterator(T_Object_list<T>& objects) 
    : T_Safe_object_iterator<T>(objects), first(objects.get_first())
    { reset(); }
  T get_next()
    {
    if (cur == stop)
      return 0;
    T ret = cur;
    cur = cur->next;
    stop = first;
    return ret;
    }
  };

typedef T_Object_iterator<Game_object *> Object_iterator;

/*
 *  Iterate through a chunk's nonflat objects.
 */
template<class T, class L>
class T_Nonflat_object_iterator : public T_Object_iterator<T>
  {
  T nonflats;
public:
  void reset()
    { this->cur = nonflats; this->stop = 0; }
  T_Nonflat_object_iterator(L chunk)
    : T_Object_iterator<T>(chunk->get_objects()), nonflats(chunk->get_first_nonflat())
    { reset(); }
  };

typedef T_Nonflat_object_iterator<Game_object *, Map_chunk *> Nonflat_object_iterator;

/*
 *  Iterate through a chunk's flat objects.
 */
template<class T, class L>
class T_Flat_object_iterator : public T_Safe_object_iterator<T>
  {
  T first;
  T stop;
  T cur;    // Next to return.
  T stop_at;
public:
  void reset()
    { cur = first; stop = 0; }
  T_Flat_object_iterator(L chunk)
    : T_Safe_object_iterator<T>(chunk->get_objects())
    {
    first = chunk->get_objects().get_first() == chunk->get_first_nonflat() ? 0 :
              chunk->get_objects().get_first();
    stop_at = chunk->get_first_nonflat() ? chunk->get_first_nonflat()
            : chunk->get_objects().get_first();
    reset();
    }
  T get_next()
    {
    if (cur == stop)
      return 0;
    T ret = cur;
    cur = cur->get_next();
    stop = stop_at;
    return ret;
    }
  };

typedef T_Flat_object_iterator<Game_object *, Map_chunk *> Flat_object_iterator;

/*
 *  Iterate backwards through list of objects.
 */
template<class T, class L>
class T_Object_iterator_backwards : public T_Safe_object_iterator<T>
  {
  T first;
  T stop;
  T cur;    // Return prev. to this.
public:
  void reset()
    { cur = first; stop = 0; }
  T_Object_iterator_backwards(L chunk) 
    : T_Safe_object_iterator<T>(chunk->get_objects()),
      first(chunk->get_objects().get_first())
    { reset(); }
  T_Object_iterator_backwards(T_Object_list<T>& objects) 
    : T_Safe_object_iterator<T>(objects),
      first(objects.get_first())
    { reset(); }
  T get_next()
    {
    if (cur == stop)
      return 0;
    cur = cur->prev;
    stop = first;
    return cur;
    }
  };

typedef T_Object_iterator_backwards<Game_object *, Map_chunk *> Object_iterator_backwards;

/*
 *  Iterate through a list of objects (recursively).
 */
template<class D> class D_Recursive_object_iterator
  {
          // Child we're going through, or 0.
  D_Recursive_object_iterator<D> *child;
  D elems;      // Goes through our elements.
public:
  D_Recursive_object_iterator(Object_list& objs)
    : elems(objs), child(0)
    {  }
          // Start at given object.
  D_Recursive_object_iterator(Game_object *obj);
  Game_object *get_next();  // Get next, going into containers.
  };

/*
 *  Iterate forwards/backwards through a list of objects (recursively).
 */
typedef D_Recursive_object_iterator<Object_iterator_backwards> 
          Recursive_object_iterator_backwards;
typedef D_Recursive_object_iterator<Object_iterator> 
          Recursive_object_iterator;

#endif

---