Template/tests/scripts/permutation.php - zetacomponents - Git at Google

 <?php
 /**
  * File containing the Permutation classes.
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  * @package
  * @version //autogen//
  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
  */

 /**
  * A system for generating permutations of possible combinations.
  *
  * @package
  * @version //autogen//
  */

 abstract class ezcTemplatePermutation
 {
     public function __construct()
     {
         $this->index = 0;
     }

     abstract public function replace( $from , $to );

     abstract public function generate();

     abstract public function increase();

     public function reset()
     {
         $this->index = 0;
     }

     static function generateString( $list )
     {
         $str = '';
         for ( $i = 0; $i < count( $list ); ++$i )
         {
             $p = $list[$i];
             if ( is_object( $p ) )
             {
                 $str .= $p->generate();
             }
             else
             {
                 $str .= $p;
             }
         }
         return $str;
     }

     static function increaseList( $list )
     {
         for ( $i = count( $list ) - 1; $i >= 0; --$i )
         {
             $p = $list[$i];
             if ( is_object( $p ) )
             {
                 if ( $p->increase() )
                     return true;
                 $p->reset();
             }
         }
         return false;
     }

     static function indentBlock( $text, $indentation )
     {
         $lines = preg_split( "#(\r\n|\r|\n)#", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
         for ( $i = 0; $i < count( $lines ); $i += 2 )
         {
             if ( $i == count( $lines ) - 1 &&
                  strlen( $lines[$i] ) == 0 )
                 continue;
             $lines[$i] = $indentation . $lines[$i];
         }
         return implode( "", $lines );
     }

     static function column( $text )
     {
         $lines = preg_split( "#(\r\n|\r|\n)#", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
         for ( $i = 0; $i < count( $lines ); $i += 2 )
         {
             if ( $i == count( $lines ) - 1 )
                 break;
         }
         $c = strlen( $lines[$i] );
         return $c;
     }

     static public function replaceList( &$list, $from, $to )
     {
         foreach ( $list as $i => $item )
         {
             if ( is_object( $item ) )
             {
                 $item->replace( $from, $to );
             }
             else
             {
                 $list[$i] = str_replace( $from, $to, $item );
             }
         }
     }
 }

 class ezcTemplatePermutationList extends ezcTemplatePermutation
 {
     public function __construct( $list = null, $indentation = '' )
     {
         parent::__construct();
         $this->list = $list;
         $this->indentation = $indentation;
     }

     public function removeIndex( $index )
     {
         if ( $index < 0 || $index >= count( $this->list ) )
         {
             throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
         }
         unset( $this->list[$index] );
         $this->list = array_values( $this->list );
     }

     public function replace( $from , $to )
     {
         self::replaceList( $this->list, $from, $to );
     }

     public function generate()
     {
         return self::indentBlock( self::generateString( $this->list ),
                                   $this->indentation );
     }

     public function increase()
     {
         return self::increaseList( $this->list );
     }
 }

 class ezcTemplatePermutationAlternative extends ezcTemplatePermutation
 {
     public function __construct( $list = null, $indentation = '' )
     {
         parent::__construct();
         $this->list = $list;
         $this->indentation = $indentation;
     }

     public function __clone()
     {
         foreach ( $this->list as $i => $v )
         {
             if ( is_object( $v ) )
             {
                 $this->list[$i] = clone $v;
             }
         }
     }

     public function removeIndex( $index )
     {
         if ( $index < 0 || $index >= count( $this->list ) )
         {
             throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
         }
         unset( $this->list[$index] );
         $this->list = array_values( $this->list );
     }

     public function replace( $from , $to )
     {
         self::replaceList( $this->list, $from, $to );
     }

     public function generate()
     {
         $p = $this->list[$this->index];
         if ( is_object( $p ) )
         {
             return self::indentBlock( $p->generate(), $this->indentation );
         }
         else
         {
             return $p;
         }
     }

     public function increase()
     {
         $p = $this->list[$this->index];
         if ( is_object( $p ) )
         {
             if ( $p->increase() )
                 return true;
             $p->reset();
         }
         $this->index++;
         return $this->index < count( $this->list );
     }

     public function reset()
     {
         foreach ( $this->list as $p )
         {
             if ( is_object( $p ) )
             {
                 $p->reset();
             }
         }
         $this->index = 0;
     }
 }

 /*class ezcTemplatePermutationOccurence extends ezcTemplatePermutation
 {
     public function __construct( $list, $min, $max )
     {
         parent::__construct();
         $this->list = $list;
         $this->min = $min;
         $this->max = $max;
     }

     public function generate()
     {
         $times = $this->min + $this->index;
         if ( $times === 0 )
             return '';

         $str = self::generateString( $this->list );
         return str_repeat( $str, $times );
     }

     public function increase()
     {
         if ( self::increase( $this->list ) )
             return true;
         $this->index++;
         return $this->index <= ( $this->max - $this->min );
     }
 }*/

 class ezcTemplatePermutationNumber extends ezcTemplatePermutation
 {
     public function __construct( $min = false, $max = false )
     {
         parent::__construct();
         $this->min = $min;
         $this->max = $max;
     }

     public function replace( $from , $to )
     {
     }

     public function generate()
     {
         return $this->min + $this->index;
     }

     public function increase()
     {
         $this->index++;
         return $this->index <= ( $this->max - $this->min );
     }
 }

 class ezcTemplatePermutationIndentChild extends ezcTemplatePermutation
 {
     public function __construct( ezcTemplatePermutation $child, $indentation )
     {
         parent::__construct();
         $this->child = $child;
         $this->indentation = $indentation;
     }

     public function replace( $from , $to )
     {
         $this->child->replace( $from, $to );
     }

     public function generate()
     {
         $p = $this->child;
         if ( is_object( $p ) )
         {
             $text = $p->generate();
         }
         else
         {
             $text = $p;
         }
         return self::indentBlock( $text,
                                   $this->indentation );
     }

     public function increase()
     {
         $p = $this->child;
         if ( is_object( $p ) )
         {
             return $p->increase();
         }
         return false;
     }

     public function reset()
     {
         $p = $this->child;
         if ( is_object( $p ) )
         {
             $p->reset();
         }
     }
 }

 class ezcTemplatePermutationAlternativeMaster extends ezcTemplatePermutation
 {
     public function __construct( array $slaves )
     {
         parent::__construct();
         $this->slaves = $slaves;
         $this->slaveIndex = count( $this->slaves ) - 1;
         if ( count( $this->slaves ) == 0 )
         {
             throw new Exception( "Slave list cannot be empty" );
         }
         foreach ( $this->slaves as $i => $slave )
         {
             if ( !$slave instanceof ezcTemplatePermutationAlternativeSlave )
             {
                 throw new Exception( "Slave entry {$i} is not an instance of ezcTemplatePermutationAlternativeSlave" );
             }
         }
     }

     public function removeIndex( $index )
     {
         if ( $index < 0 || $index >= count( $this->slaves ) )
         {
             throw new Exception( "Index $index is out of range [0->" . count( $this->slaves ) . "]" );
         }
         unset( $this->slaves[$index] );
         $this->slaves = array_values( $this->slaves );
     }

     public function __clone()
     {
         foreach ( $this->slaves as $i => $v )
         {
             if ( is_object( $v ) )
             {
                 $this->slaves[$i] = clone $v;
             }
         }
     }

     public function replace( $from , $to )
     {
         self::replaceList( $this->slaves, $from, $to );
     }

     public function generate()
     {
 //        echo "master::generate(): si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";
         $p = $this->slaves[0];
         if ( is_object( $p ) )
         {
             return $p->generate();
         }
         return $p;
     }

     public function increase()
     {
 //        echo "master::increase(): si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";

         for ( $i = count( $this->slaves ) - 1; $i >= 0; --$i )
         {
             $p = $this->slaves[$i];
             if ( is_object( $p ) )
             {
                 if ( $p->increaseSlave() )
                 {
 //                    echo "master::increase(): increaseSlave() is true\n";
                     return true;
                 }
 //                echo "master::increase(): increaseSlave() is false\n";
                 $p->resetSlave();
             }
         }

         foreach ( $this->slaves as $slave )
         {
             $slave->index++;
         }
         $ret = $this->slaves[0]->index < count( $this->slaves[0]->list );
 //        echo "master::increase()#3: ret: '$ret', si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";
         return $ret;

     }

     public function reset()
     {
         foreach ( $this->slaves as $slave )
         {
             $slave->resetSlaves();
         }
     }
 }

 class ezcTemplatePermutationAlternativeSlave extends ezcTemplatePermutation
 {
     public function __construct( $list )
     {
         parent::__construct();
         $this->list = $list;
         $this->index = 0;
     }

     public function __clone()
     {
         foreach ( $this->list as $i => $v )
         {
             if ( is_object( $v ) )
             {
                 $this->list[$i] = clone $v;
             }
         }
     }

     public function removeIndex( $index )
     {
         if ( $index < 0 || $index >= count( $this->list ) )
         {
             throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
         }
         unset( $this->list[$index] );
         $this->list = array_values( $this->list );
     }

     public function replace( $from , $to )
     {
         self::replaceList( $this->list, $from, $to );
     }

     public function generate()
     {
         $p = $this->list[$this->index];
         if ( is_object( $p ) )
         {
             return $p->generate();
         }
         return $p;
     }

     public function increaseSlave()
     {
 //        echo "slave::increaseSlave(): i: {$this->index}\n";
         $p = $this->list[$this->index];
         if ( is_object( $p ) )
         {
             return $p->increase();
         }
         return false;
     }

     public function increase()
     {
         // Slaves do not control the increase(), this is up to the master.
 //        echo "slave::increase(): i: {$this->index}\n";
         return false;
     }

     public function setIndex( $index )
     {
 //        echo "slave::setIndex( $index )\n";
         if ( $index >= count( $this->list ) )
         {
             throw new Exception( "New index {$index} is out of bounds (" . count( $this->list ) . ")" );
         }
         $this->index = $index;
     }

     public function resetSlave()
     {
         $p = $this->list[$this->index];
         if ( is_object( $p ) )
         {
             return $p->reset();
         }
     }

     public function resetSlaves()
     {
         foreach ( $this->list as $p )
         {
             if ( is_object( $p ) )
             {
                 return $p->reset();
             }
         }
         $this->index = 0;
     }

     public function reset()
     {
         // Slaves do not control the reset(), this is up to the master.
         return false;
     }
 }

 class ezcTemplatePermutationApp
 {
     public $outputToFile;

     public function __construct( $file, $args = false, $dir = false )
     {
         $this->outputToFile = false;
         if ( $dir === false )
         {
             $dir = dirname( __FILE__ ) . "/../regression_tests";
         }
         $this->fd = false;
         $this->dir = $dir;
         $this->file = $file;

         if ( is_array( $args ) )
         {
             foreach ( $args as $arg )
             {
                 if ( $arg == '--generate-file' )
                     $this->outputToFile = true;
             }
         }
     }

     public function store( $content, $file = false )
     {
         if ( $file === false )
             $file = $this->dir . '/' . $this->file;

         if ( $this->outputToFile )
         {
             if ( !file_exists( dirname( $file ) ) )
             {
                 mkdir( dirname( $file ), 0777, true );
             }

             echo "Writing to ", $file, "\n";
             file_put_contents( $file, $content );
             return $file;
         }
         else
         {
             echo basename( $file ), "\n";
             echo $content, "\n";
             return false;
         }
     }

     public function output( $content )
     {
         if ( $this->outputToFile )
         {
             if ( $this->fd === false )
             {
                 $file = $this->dir . '/' . $this->file;
                 if ( !file_exists( dirname( $file ) ) )
                 {
                     mkdir( dirname( $file ), 0777, true );
                 }
                 $this->fd = fopen( $file, "w" );
             }
             fwrite( $this->fd, $content );
         }
         else
         {
             echo $content;
         }
     }

     public function close()
     {
         if ( $this->outputToFile )
         {
             if ( $this->fd === false )
             {
                 throw new Exception( "File has not yet been opened" );
             }
             echo "Writing to ", $this->dir . "/" . $this->file, "\n";
             fclose( $this->fd );
             $this->fd = false;
         }
     }
 }

 function app( $file, $args, $dir = false )
 {
     return new ezcTemplatePermutationApp( $file, $args, $dir );
 }

 function perm()
 {
     $args = func_get_args();
     return new ezcTemplatePermutationList( $args );
 }

 function permI()
 {
     $args = func_get_args();
     $indent = array_shift( $args );
     return new ezcTemplatePermutationList( $args, $indent );
 }

 function alt()
 {
     $args = func_get_args();
     return new ezcTemplatePermutationAlternative( $args );
 }

 function altI()
 {
     $args = func_get_args();
     $indent = array_shift( $args );
     return new ezcTemplatePermutationAlternative( $args, $indent );
 }

 function indent( $child, $indentation )
 {
     return new ezcTemplatePermutationIndentChild( $child, $indentation );
 }

 function num( $min = false, $max = false )
 {
     return new ezcTemplatePermutationNumber( $min, $max );
 }

 function altMaster()
 {
     $slaves = func_get_args();
     return new ezcTemplatePermutationAlternativeMaster( $slaves );
 }

 function altSlave()
 {
     $list = func_get_args();
     return new ezcTemplatePermutationAlternativeSlave( $list );
 }

 ?>
	<?php
	/**
	* File containing the Permutation classes.
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	* @package
	* @version //autogen//
	* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
	*/

	/**
	* A system for generating permutations of possible combinations.
	*
	* @package
	* @version //autogen//
	*/

	abstract class ezcTemplatePermutation
	{
	public function __construct()
	{
	$this->index = 0;
	}

	abstract public function replace( $from , $to );

	abstract public function generate();

	abstract public function increase();

	public function reset()
	{
	$this->index = 0;
	}

	static function generateString( $list )
	{
	$str = '';
	for ( $i = 0; $i < count( $list ); ++$i )
	{
	$p = $list[$i];
	if ( is_object( $p ) )
	{
	$str .= $p->generate();
	}
	else
	{
	$str .= $p;
	}
	}
	return $str;
	}

	static function increaseList( $list )
	{
	for ( $i = count( $list ) - 1; $i >= 0; --$i )
	{
	$p = $list[$i];
	if ( is_object( $p ) )
	{
	if ( $p->increase() )
	return true;
	$p->reset();
	}
	}
	return false;
	}

	static function indentBlock( $text, $indentation )
	{
	$lines = preg_split( "#(\r\n\|\r\|\n)#", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
	for ( $i = 0; $i < count( $lines ); $i += 2 )
	{
	if ( $i == count( $lines ) - 1 &&
	strlen( $lines[$i] ) == 0 )
	continue;
	$lines[$i] = $indentation . $lines[$i];
	}
	return implode( "", $lines );
	}

	static function column( $text )
	{
	$lines = preg_split( "#(\r\n\|\r\|\n)#", $text, -1, PREG_SPLIT_DELIM_CAPTURE );
	for ( $i = 0; $i < count( $lines ); $i += 2 )
	{
	if ( $i == count( $lines ) - 1 )
	break;
	}
	$c = strlen( $lines[$i] );
	return $c;
	}

	static public function replaceList( &$list, $from, $to )
	{
	foreach ( $list as $i => $item )
	{
	if ( is_object( $item ) )
	{
	$item->replace( $from, $to );
	}
	else
	{
	$list[$i] = str_replace( $from, $to, $item );
	}
	}
	}
	}

	class ezcTemplatePermutationList extends ezcTemplatePermutation
	{
	public function __construct( $list = null, $indentation = '' )
	{
	parent::__construct();
	$this->list = $list;
	$this->indentation = $indentation;
	}

	public function removeIndex( $index )
	{
	if ( $index < 0 \|\| $index >= count( $this->list ) )
	{
	throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
	}
	unset( $this->list[$index] );
	$this->list = array_values( $this->list );
	}

	public function replace( $from , $to )
	{
	self::replaceList( $this->list, $from, $to );
	}

	public function generate()
	{
	return self::indentBlock( self::generateString( $this->list ),
	$this->indentation );
	}

	public function increase()
	{
	return self::increaseList( $this->list );
	}
	}

	class ezcTemplatePermutationAlternative extends ezcTemplatePermutation
	{
	public function __construct( $list = null, $indentation = '' )
	{
	parent::__construct();
	$this->list = $list;
	$this->indentation = $indentation;
	}

	public function __clone()
	{
	foreach ( $this->list as $i => $v )
	{
	if ( is_object( $v ) )
	{
	$this->list[$i] = clone $v;
	}
	}
	}

	public function removeIndex( $index )
	{
	if ( $index < 0 \|\| $index >= count( $this->list ) )
	{
	throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
	}
	unset( $this->list[$index] );
	$this->list = array_values( $this->list );
	}

	public function replace( $from , $to )
	{
	self::replaceList( $this->list, $from, $to );
	}

	public function generate()
	{
	$p = $this->list[$this->index];
	if ( is_object( $p ) )
	{
	return self::indentBlock( $p->generate(), $this->indentation );
	}
	else
	{
	return $p;
	}
	}

	public function increase()
	{
	$p = $this->list[$this->index];
	if ( is_object( $p ) )
	{
	if ( $p->increase() )
	return true;
	$p->reset();
	}
	$this->index++;
	return $this->index < count( $this->list );
	}

	public function reset()
	{
	foreach ( $this->list as $p )
	{
	if ( is_object( $p ) )
	{
	$p->reset();
	}
	}
	$this->index = 0;
	}
	}

	/*class ezcTemplatePermutationOccurence extends ezcTemplatePermutation
	{
	public function __construct( $list, $min, $max )
	{
	parent::__construct();
	$this->list = $list;
	$this->min = $min;
	$this->max = $max;
	}

	public function generate()
	{
	$times = $this->min + $this->index;
	if ( $times === 0 )
	return '';

	$str = self::generateString( $this->list );
	return str_repeat( $str, $times );
	}

	public function increase()
	{
	if ( self::increase( $this->list ) )
	return true;
	$this->index++;
	return $this->index <= ( $this->max - $this->min );
	}
	}*/

	class ezcTemplatePermutationNumber extends ezcTemplatePermutation
	{
	public function __construct( $min = false, $max = false )
	{
	parent::__construct();
	$this->min = $min;
	$this->max = $max;
	}

	public function replace( $from , $to )
	{
	}

	public function generate()
	{
	return $this->min + $this->index;
	}

	public function increase()
	{
	$this->index++;
	return $this->index <= ( $this->max - $this->min );
	}
	}

	class ezcTemplatePermutationIndentChild extends ezcTemplatePermutation
	{
	public function __construct( ezcTemplatePermutation $child, $indentation )
	{
	parent::__construct();
	$this->child = $child;
	$this->indentation = $indentation;
	}

	public function replace( $from , $to )
	{
	$this->child->replace( $from, $to );
	}

	public function generate()
	{
	$p = $this->child;
	if ( is_object( $p ) )
	{
	$text = $p->generate();
	}
	else
	{
	$text = $p;
	}
	return self::indentBlock( $text,
	$this->indentation );
	}

	public function increase()
	{
	$p = $this->child;
	if ( is_object( $p ) )
	{
	return $p->increase();
	}
	return false;
	}

	public function reset()
	{
	$p = $this->child;
	if ( is_object( $p ) )
	{
	$p->reset();
	}
	}
	}

	class ezcTemplatePermutationAlternativeMaster extends ezcTemplatePermutation
	{
	public function __construct( array $slaves )
	{
	parent::__construct();
	$this->slaves = $slaves;
	$this->slaveIndex = count( $this->slaves ) - 1;
	if ( count( $this->slaves ) == 0 )
	{
	throw new Exception( "Slave list cannot be empty" );
	}
	foreach ( $this->slaves as $i => $slave )
	{
	if ( !$slave instanceof ezcTemplatePermutationAlternativeSlave )
	{
	throw new Exception( "Slave entry {$i} is not an instance of ezcTemplatePermutationAlternativeSlave" );
	}
	}
	}

	public function removeIndex( $index )
	{
	if ( $index < 0 \|\| $index >= count( $this->slaves ) )
	{
	throw new Exception( "Index $index is out of range [0->" . count( $this->slaves ) . "]" );
	}
	unset( $this->slaves[$index] );
	$this->slaves = array_values( $this->slaves );
	}

	public function __clone()
	{
	foreach ( $this->slaves as $i => $v )
	{
	if ( is_object( $v ) )
	{
	$this->slaves[$i] = clone $v;
	}
	}
	}

	public function replace( $from , $to )
	{
	self::replaceList( $this->slaves, $from, $to );
	}

	public function generate()
	{
	// echo "master::generate(): si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";
	$p = $this->slaves[0];
	if ( is_object( $p ) )
	{
	return $p->generate();
	}
	return $p;
	}

	public function increase()
	{
	// echo "master::increase(): si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";

	for ( $i = count( $this->slaves ) - 1; $i >= 0; --$i )
	{
	$p = $this->slaves[$i];
	if ( is_object( $p ) )
	{
	if ( $p->increaseSlave() )
	{
	// echo "master::increase(): increaseSlave() is true\n";
	return true;
	}
	// echo "master::increase(): increaseSlave() is false\n";
	$p->resetSlave();
	}
	}

	foreach ( $this->slaves as $slave )
	{
	$slave->index++;
	}
	$ret = $this->slaves[0]->index < count( $this->slaves[0]->list );
	// echo "master::increase()#3: ret: '$ret', si: {$this->slaveIndex}, sc: " . count( $this->slaves ) . "\n";
	return $ret;

	}

	public function reset()
	{
	foreach ( $this->slaves as $slave )
	{
	$slave->resetSlaves();
	}
	}
	}

	class ezcTemplatePermutationAlternativeSlave extends ezcTemplatePermutation
	{
	public function __construct( $list )
	{
	parent::__construct();
	$this->list = $list;
	$this->index = 0;
	}

	public function __clone()
	{
	foreach ( $this->list as $i => $v )
	{
	if ( is_object( $v ) )
	{
	$this->list[$i] = clone $v;
	}
	}
	}

	public function removeIndex( $index )
	{
	if ( $index < 0 \|\| $index >= count( $this->list ) )
	{
	throw new Exception( "Index $index is out of range [0->" . count( $this->list ) . "]" );
	}
	unset( $this->list[$index] );
	$this->list = array_values( $this->list );
	}

	public function replace( $from , $to )
	{
	self::replaceList( $this->list, $from, $to );
	}

	public function generate()
	{
	$p = $this->list[$this->index];
	if ( is_object( $p ) )
	{
	return $p->generate();
	}
	return $p;
	}

	public function increaseSlave()
	{
	// echo "slave::increaseSlave(): i: {$this->index}\n";
	$p = $this->list[$this->index];
	if ( is_object( $p ) )
	{
	return $p->increase();
	}
	return false;
	}

	public function increase()
	{
	// Slaves do not control the increase(), this is up to the master.
	// echo "slave::increase(): i: {$this->index}\n";
	return false;
	}

	public function setIndex( $index )
	{
	// echo "slave::setIndex( $index )\n";
	if ( $index >= count( $this->list ) )
	{
	throw new Exception( "New index {$index} is out of bounds (" . count( $this->list ) . ")" );
	}
	$this->index = $index;
	}

	public function resetSlave()
	{
	$p = $this->list[$this->index];
	if ( is_object( $p ) )
	{
	return $p->reset();
	}
	}

	public function resetSlaves()
	{
	foreach ( $this->list as $p )
	{
	if ( is_object( $p ) )
	{
	return $p->reset();
	}
	}
	$this->index = 0;
	}

	public function reset()
	{
	// Slaves do not control the reset(), this is up to the master.
	return false;
	}
	}

	class ezcTemplatePermutationApp
	{
	public $outputToFile;

	public function __construct( $file, $args = false, $dir = false )
	{
	$this->outputToFile = false;
	if ( $dir === false )
	{
	$dir = dirname( __FILE__ ) . "/../regression_tests";
	}
	$this->fd = false;
	$this->dir = $dir;
	$this->file = $file;

	if ( is_array( $args ) )
	{
	foreach ( $args as $arg )
	{
	if ( $arg == '--generate-file' )
	$this->outputToFile = true;
	}
	}
	}

	public function store( $content, $file = false )
	{
	if ( $file === false )
	$file = $this->dir . '/' . $this->file;

	if ( $this->outputToFile )
	{
	if ( !file_exists( dirname( $file ) ) )
	{
	mkdir( dirname( $file ), 0777, true );
	}

	echo "Writing to ", $file, "\n";
	file_put_contents( $file, $content );
	return $file;
	}
	else
	{
	echo basename( $file ), "\n";
	echo $content, "\n";
	return false;
	}
	}

	public function output( $content )
	{
	if ( $this->outputToFile )
	{
	if ( $this->fd === false )
	{
	$file = $this->dir . '/' . $this->file;
	if ( !file_exists( dirname( $file ) ) )
	{
	mkdir( dirname( $file ), 0777, true );
	}
	$this->fd = fopen( $file, "w" );
	}
	fwrite( $this->fd, $content );
	}
	else
	{
	echo $content;
	}
	}

	public function close()
	{
	if ( $this->outputToFile )
	{
	if ( $this->fd === false )
	{
	throw new Exception( "File has not yet been opened" );
	}
	echo "Writing to ", $this->dir . "/" . $this->file, "\n";
	fclose( $this->fd );
	$this->fd = false;
	}
	}
	}

	function app( $file, $args, $dir = false )
	{
	return new ezcTemplatePermutationApp( $file, $args, $dir );
	}

	function perm()
	{
	$args = func_get_args();
	return new ezcTemplatePermutationList( $args );
	}

	function permI()
	{
	$args = func_get_args();
	$indent = array_shift( $args );
	return new ezcTemplatePermutationList( $args, $indent );
	}

	function alt()
	{
	$args = func_get_args();
	return new ezcTemplatePermutationAlternative( $args );
	}

	function altI()
	{
	$args = func_get_args();
	$indent = array_shift( $args );
	return new ezcTemplatePermutationAlternative( $args, $indent );
	}

	function indent( $child, $indentation )
	{
	return new ezcTemplatePermutationIndentChild( $child, $indentation );
	}

	function num( $min = false, $max = false )
	{
	return new ezcTemplatePermutationNumber( $min, $max );
	}

	function altMaster()
	{
	$slaves = func_get_args();
	return new ezcTemplatePermutationAlternativeMaster( $slaves );
	}

	function altSlave()
	{
	$list = func_get_args();
	return new ezcTemplatePermutationAlternativeSlave( $list );
	}

	?>