/*
 *  Copyright (C) 1999, 2000, 2001, 2002
 *  Heikki Tauriainen <Heikki.Tauriainen@hut.fi>
 *
 *  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 PATHITERATOR_H
#define PATHITERATOR_H

#ifdef __GNUC__
#pragma interface
#endif /* __GNUC__ */

#include <config.h>
#include "StateSpace.h"

using namespace std;

namespace Graph
{

/******************************************************************************
 *
 * An iterator class for systematically enumerating all state spaces consisting
 * of a single infinite path (a prefix and a loop) with a given number of
 * states and a given number of atomic propositions in each state.
 *
 *****************************************************************************/

class PathIterator
{
public:
  PathIterator                                      /* Constructor. */
    (unsigned long int propositions_per_state,
     StateSpace::size_type number_of_states);

  /* default copy constructor */

  ~PathIterator();                                  /* Destructor. */

  /* default assignment operator */

  bool operator==(const PathIterator& it)           /* Equivalence operator. */
    const;

  bool operator!=(const PathIterator& it)           /* Inequivalence operator.
						     */
    const;

  const StateSpace& operator*() const;              /* Dereferencing */
  const StateSpace* operator->() const;             /* operators.    */

  const StateSpace& operator++();                   /* Increment operators. */
  const StateSpace operator++(int);

  bool atEnd() const;                               /* Tells whether the
						     * iterator has enumerated
						     * all the state spaces in
						     * the range determined by
						     * the parameters with
						     * which the iterator was
						     * initialized.
						     */
						     
private:
  void computeNextPath();                           /* Updates the state space
						     * currently pointed to by
						     * the iterator.
						     */

  StateSpace path;                                  /* The state space (the
						     * path) currently pointed
						     * to by the iterator.
						     */

  StateSpace::size_type loop_target_state;          /* Identifier of the target
						     * state of the last state
						     * in the path.
						     */
};



/******************************************************************************
 *
 * Inline function definitions for class PathIterator.
 *
 *****************************************************************************/

/* ========================================================================= */
inline PathIterator::~PathIterator()
/* ----------------------------------------------------------------------------
 *
 * Description:   Destructor for class PathIterator.
 *
 * Arguments:     None.
 *
 * Returns:       Nothing.
 *
 * ------------------------------------------------------------------------- */
{
}

/* ========================================================================= */
inline const StateSpace& PathIterator::operator*() const
/* ----------------------------------------------------------------------------
 *
 * Description:   Dereferencing operator for class PathIterator. Gives access
 *                to the state space currently pointed to by the iterator.
 *
 * Arguments:     None.
 *
 * Returns:       A constant reference to the state space currently pointed to
 *                by the iterator.
 *
 * ------------------------------------------------------------------------- */
{
  return path;
}

/* ========================================================================= */
inline const StateSpace* PathIterator::operator->() const
/* ----------------------------------------------------------------------------
 *
 * Description:   Dereferencing operator for class PathIterator. Gives access
 *                to the state space currently pointed to by the iterator.
 *
 * Arguments:     None.
 *
 * Returns:       A pointer to a constant state space currently pointed to by
 *                the iterator.
 *
 * ------------------------------------------------------------------------- */
{
  return &path;
}

/* ========================================================================= */
inline const StateSpace& PathIterator::operator++()
/* ----------------------------------------------------------------------------
 *
 * Description:   Prefix increment operator for class PathIterator. Computes
 *                the next path in the graph sequence and returns a constant
 *                reference to it.
 *
 * Arguments:     None.
 *
 * Returns:       A constant reference to the updated state space pointer to by
 *                the iterator.
 *
 * ------------------------------------------------------------------------- */
{
  computeNextPath();
  return path;
}

/* ========================================================================= */
inline const StateSpace PathIterator::operator++(int)
/* ----------------------------------------------------------------------------
 *
 * Description:   Postfix increment operator for class PathIterator. Computes
 *                the next path in the graph sequence and returns the graph
 *                pointed to by the iterator after this operation.
 *
 * Arguments:     None.
 *
 * Returns:       A constant reference to the state space pointed to by the
 *                iterator before computing the next path in the sequence.
 *
 * ------------------------------------------------------------------------- */
{
  StateSpace old_path(path);
  computeNextPath();
  return old_path;
}

/* ========================================================================= */
inline bool PathIterator::atEnd() const
/* ----------------------------------------------------------------------------
 *
 * Description:   Tells whether all possible paths have been enumerated by the
 *                iterator.
 *
 * Arguments:     None.
 *
 * Returns:       A truth value according to the result of the test.
 *
 * ------------------------------------------------------------------------- */
{
  return (loop_target_state == path.size());
}
 
}

#endif  /* !PATHITERATOR_H */