<?php
/** @package PHP_UML::tests */

/**
* Base class for all output converters.
* A Converter takes output from the {@link Parser} and converts it to template-friendly output.  A converter for the standard phpDocumentor
* template, {@link HTMLConverter}, is provided with this release.  Future releases will have support for other formats and templates, including
* DocBook, XML, and possibly other HTML templates.  The converter takes output directly from {@link NewRender} and using {@link walk()} it
* "walks" over an array of phpDocumentor elements, as represented by descendants of {@link parserElement}
*
* a converter must define the abstract function Convert (an example is {@link HTMLConverter::Convert()}), a function that takes a passed object
* and uses it to generate structures for an output template, or directly generates output.  Since all elements have their DocBlocks linked
* directly, this allows for more logical parsing than earlier versions of phpDocumentor.
*
* A Converter is passed several data structures in its constructor, all of which are optional in output and may be handled in any way
* the converter would like.  These structures are arrays:
* <ul>
*	<li>array of methods by class (see {@link NewRender::$methods})</li>
*	<li>array of variables by class (see {@link NewRender::$vars})</li>
*	<li>array of links to documented elements (see {@link NewRender::$links})</li>
*	<li>array of class parents by name (see {@link NewRender::$classtree})</li>
*	<li>array of class packages by classname (see {@link NewRender::$classpackages})</li>
*	<li>array of packages to document (see {@link NewRender::$packageoutput})</li>
*	<li>array of extended classes by parent classname (see {@link NewRender::$class_children})</li>
*	<li>array of all documented elements by name (see {@link NewRender::$elements})</li>
*	<li>array of all documented elements by name, split by package (see {@link NewRender::$pkg_elements})</li>
*	<li>boolean option, set to true to parse all elements marked @access private (see {@link NewRender::$parsePrivate})</li>
*	<li>boolean option, set to true to stop informative output while parsing (good for cron jobs) (see {@link NewRender::$quietMode})</li>
* </ul>
* @package PHP_UML::tests
* @abstract
* @see parserDocBlock, parserInclude, parserPage, parserClass, parserDefine, parserFunction, parserMethod, parserVar
*/
class iConverter
{

	function walk()
	{
	}
}

/**
* @package PHP_UML::tests
*/
class iParser
{
}

class iHTMLConverter extends iConverter
{
	function Convert()
	{
	}
}

/**
* @package PHP_UML::tests
*/
class iparserElement
{
}

/**
* @package PHP_UML::tests
*/
class iNewRender
{
	/**
	* array of methods by package, subpackage and class
	* format:
	* array(packagename =>
	*       array(subpackagename =>
	*             array(classname =>
	*                   array(methodname1 => {@link parserMethod} class,
	*                         methodname2 => {@link parserMethod} class,...)
	*					     )
	*                  )
	*            )
	*      )
	* @var array
	* @see Converter
	*/
	var $methods = array();
	
	/**
	* array of class variables by package, subpackage and class
	* format:
	* array(packagename =>
	*       array(subpackagename =>
	*             array(classname =>
	*                   array(variablename1 => {@link parserMethod} class,
	*                         variablename2 => {@link parserMethod} class,...)
	*					     )
	*                  )
	*            )
	*      )
	* @var array
	* @see Converter
	*/
	var $vars = array();
	
	/**
	* set in {@link phpdoc.inc} to the value of the parserprivate commandline option.
	* If this option is true, elements with an @access private tag will be parsed and displayed
	* @var bool
	*/
	var $parsePrivate = false;
	
	/**
	* this variable is used to prevent parsing of private elements if $parsePrivate is false.
	* it is also used by the packageoutput setting to prevent parsing of elements that aren't in the
	* desired output packages
	* @see $packageoutput
	* @see $parsePrivate
	*/
	var $private_class = false;
	
	/**
	* the workhorse of linking.
	* This array is an array of link objects of format:
	* [package][subpackage][eltype][elname] = descendant of {@link abstractLink}
	* eltype can be page|include|function|define|class|method|var
	* if eltype is method or var, the array format is:
	* [package][subpackage][eltype][class][elname]
	* @var array
	* @see functionLink, pageLink, classLink, defineLink, methodLink, varLink
	*/
	var $links = array();
	
	/**
	* a tree of class inheritance by name.
	* format:
	* array(childname => parentname,
	*       childname1 => parentname1,
	*       rootname => 0, ...
	*      )
	* @var array
	* @see Converter::generateClassTreeFromClass()
	*/
	var $classtree = array();
	
	/**
	* used in {@link Converter::getClassPackage()} to inherit package from parent classes.
	* format:
	* array(classname => array(array(package,subpackage),
	*                          array(package1,subpackage1),....
	                          )
		   )
	* If a name conflict exists between two packages, automatic inheritance will not work, and the packages will need
	* to be documented separately.
	* @var array
	*/
	var $classpackages = array();
	
	/**
	* used to set the output directory
	* @see setTargetDir()
	*/
	var $targetDir;
	
	/**
	* array of class inheritance indexed by parent class and package
	*
	* Format:
	* array(Packagename => array(ParentClassname1 => array(Child1name,Child2name),
	*                            ParentClassname2 => array(Child1name,Child2name),...
	*                           )
	*      )
	* @see Converter::getRootTree()
	* @var array
	*/
	
	/**
	* An array of extended classes by package and parent class
	* Format:
	* array(packagename => array(parentclass => array(childclassname1,
	*                                                 childclassname2,...
	*                                                )
	*                       )
	*      )
	* @var array
	*/
	var $class_children = array();
	
	var $elements = array();
	
	var $pkg_elements = array();

	var $pages = array();

	/**
	* array of packages to parser and output documentation for, if not all packages should be documented
	* Format:
	* array(package1,package2,...)
	*   or false if not set
	* Use this option to limit output similar to ignoring files.  If you have some temporary files that you don't want to specify by name
	* but don't want included in output, set a package name for all the elements in your project, and set packageoutput to that name.
	* the default package will be ignored.  Parsing speed does not improve.  If you want to ignore files for speed reasons, use the ignore
	* command-line option
	* @see Io
	* @var mixed
	*/
	var $packageoutput = false;
	
	/**
	* the functions which handle output from the {@link Parser}
	* @see handleEvent(), handleDocBlock(), handlePage(), handleClass(), handleDefine(), handleFunction(), handleMethod(), handleVar(),
	*      handlePackagePage(), handleInclude()
	*/
	var $event_handlers = array(
			'docblock' => 'handleDocBlock',
			'page' => 'handlePage',
			'class' => 'handleClass',
			'define' => 'handleDefine',
			'function' => 'handleFunction',
			'method' => 'handleMethod',
			'var' => 'handleVar',
			'packagepage' => 'handlePackagePage',
			'include' => 'handleInclude',
			);
	
	/**
	* data contains parsed structures for the current page being parsed
	* @var parserData
	* @see parserData
	*/
	var $data;
	
	/**
	* set to the name of the package of the current class being parsed
	* @var string
	*/
	var $classpackage = 'default';
	
	/**
	* set to the name of the subpackage of the current class being parsed
	* @var string
	*/
	var $classsubpackage = '';
	
	/**
	* set in {@link phpdoc.inc} to the value of the quitemode commandline option.
	* If this option is true, informative output while parsing will not be displayed (documentation is unaffected)
	* @var bool
	*/
	var $quietMode = false;


}
?>