diff options
Diffstat (limited to 'buildscripts/PhpDocumentor/phpDocumentor/ParserElements.inc')
| -rw-r--r-- | buildscripts/PhpDocumentor/phpDocumentor/ParserElements.inc | 1910 |
1 files changed, 1910 insertions, 0 deletions
diff --git a/buildscripts/PhpDocumentor/phpDocumentor/ParserElements.inc b/buildscripts/PhpDocumentor/phpDocumentor/ParserElements.inc new file mode 100644 index 00000000..a95d24b8 --- /dev/null +++ b/buildscripts/PhpDocumentor/phpDocumentor/ParserElements.inc @@ -0,0 +1,1910 @@ +<?php
+//
+// +------------------------------------------------------------------------+
+// | phpDocumentor |
+// +------------------------------------------------------------------------+
+// | Copyright (c) 2000-2003 Joshua Eichorn, Gregory Beaver |
+// | Email jeichorn@phpdoc.org, cellog@phpdoc.org |
+// | Web http://www.phpdoc.org |
+// | Mirror http://phpdocu.sourceforge.net/ |
+// | PEAR http://pear.php.net/package-info.php?pacid=137 |
+// +------------------------------------------------------------------------+
+// | This source file is subject to version 3.00 of the PHP License, |
+// | that is available at http://www.php.net/license/3_0.txt. |
+// | If you did not receive a copy of the PHP license and are unable to |
+// | obtain it through the world-wide-web, please send a note to |
+// | license@php.net so we can mail you a copy immediately. |
+// +------------------------------------------------------------------------+
+//
+
+/**
+ * Parser Elements, all classes representing documentable elements
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @since 1.1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+
+/**
+ * all elements except {@link parserPackagePage} descend from this abstract class
+ * @abstract
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserElement extends parserBase
+{
+ /**
+ * @var mixed either false or a {@link parserDocBlock}
+ */
+ var $docblock = false;
+ /**
+ * name of this element, or include type if element is a {@link parserInclude}
+ */
+ var $name;
+
+ /**
+ * @var mixed either false or an array of paths to files with conflicts
+ */
+ var $conflicts = false;
+
+ /**
+ * location of this element (filename)
+ * @var string
+ */
+ var $file = '';
+
+ /**
+ * full path location of this element (filename)
+ * @var string
+ */
+ var $path = '';
+
+ /**
+ * line number on file where this element stops
+ * @since 1.2
+ * @var false|integer
+ */
+ var $endlinenumber = 0;
+
+ /**
+ * Line number in the source on which this element appears
+ * @since 1.2
+ * @var false|integer
+ */
+ var $linenumber = false;
+
+ /**
+ * @param parserDocBlock
+ */
+ function setDocBlock($docblock)
+ {
+ $this->docblock = $docblock;
+ }
+
+ /**
+ * @param string
+ */
+ function setName($name)
+ {
+ $this->name = trim($name);
+ }
+
+ /**
+ * Set starting line number
+ * @param integer
+ */
+ function setLineNumber($number)
+ {
+ $this->linenumber = $number;
+ }
+
+ /**
+ * Sets the ending line number of elements
+ * @param integer
+ */
+ function setEndLineNumber($l)
+ {
+ $this->endlinenumber = $l;
+ }
+
+ /**
+ * @return integer
+ */
+ function getLineNumber()
+ {
+ return $this->linenumber;
+ }
+
+ /**
+ * @return integer
+ */
+ function getEndLineNumber()
+ {
+ return $this->endlinenumber;
+ }
+
+ /** @return string package containing this element */
+ function getPackage()
+ {
+ if ($this->docblock)
+ {
+ return $this->docblock->package;
+ } else return $GLOBALS['phpDocumentor_DefaultPackageName'];
+ }
+
+ /** @param string */
+ function setFile($file)
+ {
+ $this->file = $file;
+ }
+
+ /** @param string */
+ function setPath($file)
+ {
+ // look for special windows case
+ if(SMART_PATH_DELIMITER === '\\')
+ $this->path = strtr($file,'/','\\');
+ else
+ $this->path = $file;
+ $this->path = $file;
+ }
+
+ /**
+ * @return string
+ */
+ function getName()
+ {
+ if (!isset($this->name)) return false;
+ return $this->name;
+ }
+
+ /**
+ * @return string
+ */
+ function getFile()
+ {
+ if (!isset($this->file)) return false;
+ return $this->file;
+ }
+
+ /**
+ * @return string
+ */
+ function getPath()
+ {
+ if (!isset($this->path)) return false;
+ return $this->path;
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserInclude extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'include'
+ */
+ var $type = 'include';
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserGlobal extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'global'
+ */
+ var $type = 'global';
+
+ /**
+ * Name of the global's data type
+ * @var string
+ */
+ var $datatype = 'mixed';
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this global variable
+ * @param Converter
+ * @param string text to display for the link or false for default text
+ */
+ function getLink(&$c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink('global ' . $this->name, $this->docblock->package);
+ }
+ return $c->getGlobalLink($this->name, $this->docblock->package, $this->path, $text);
+ }
+
+ /**
+ * Returns all global variables in other packages that have the same name as this global variable
+ * @return mixed false or an array Format: (package => {@link parserGlobal} of conflicting global variable)
+ * @param Converter
+ */
+ function getConflicts(&$c)
+ {
+ $a = $c->proceduralpages->getGlobalConflicts($this->name);
+ unset($a[$this->docblock->package]);
+ return $a;
+ }
+
+ /**
+ * Sets the name of the global variable's type
+ * @param string
+ */
+ function setDataType($type)
+ {
+ $this->datatype = $type;
+ }
+
+ /**
+ * Retrieve converter-specific representation of the data type
+ *
+ * If the data type is a documented class name, then this function will
+ * return a Converter-specific link to that class's documentation, so users
+ * can click/browse to the documentation directly from the global variable
+ * declaration
+ * @return string
+ * @param Converter
+ */
+ function getDataType(&$converter)
+ {
+ $converted_datatype = $this->datatype;
+ if (strpos($this->datatype,'|'))
+ {
+ $types = explode('|',$this->datatype);
+ foreach($types as $returntype)
+ {
+ $a = $converter->getLink($returntype);
+ if (is_object($a) && phpDocumentor_get_class($a) == 'classlink')
+ {
+ if (!empty($my_types)) $my_types .= '|';
+ $my_types .= $converter->returnSee($a,$converter->type_adjust($returntype));
+ } else
+ {
+ if (!empty($my_types)) $my_types .= '|';
+ $my_types .= $converter->type_adjust($returntype);
+ }
+ }
+ $converted_datatype = $my_types;
+ } else
+ {
+ $a = $converter->getLink($this->datatype);
+ if (is_object($a) && phpDocumentor_get_class($a) == 'classlink')
+ {
+ $converted_datatype = $converter->returnSee($a,$converter->type_adjust($this->datatype));
+ } else
+ {
+ $converted_dataype = $converter->type_adjust($this->datatype);
+ }
+ }
+ return $converted_datatype;
+ }
+
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserFunction extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'function'
+ */
+ var $type = 'function';
+ /**
+ * parameters parsed from function definition.
+ *
+ * param name may be null, in which case, updateParams() must be called from the Converter
+ * @var array Format: array(param name => default value parsed from function definition)
+ * @see updateParams()
+ */
+ var $params = false;
+ /**
+ * Function returns a reference to an element, instead of a value
+ *
+ * set to true if function is declared as:
+ * <code>
+ * function &func(...
+ * </code>
+ * @var boolean
+ */
+ var $returnsreference = false;
+ /**
+ * global declarations parsed from function definition
+ *
+ * @var array Format: array(globalname1, globalname2,....)
+ */
+ var $globals = false;
+ /**
+ * static variable declarations parsed from function definition
+ * @var array Format: array(array('name' => staticvar1,'val' => '' or default val of staticvar1),...)
+ */
+ var $statics = false;
+
+ var $source = '';
+ /**
+ * @param string
+ * @param string default value parsed from function definition
+ * @param boolean indicates whether this parameter has a default value
+ */
+ function addParam($name, $value, $has_default = true)
+ {
+ $this->params[$name] = array($value, $has_default);
+ }
+
+ /**
+ * Set the source code. Always array in PHP 4.3.0+
+ * @param string|array
+ */
+ function addSource($source)
+ {
+ $this->source = $source;
+ }
+
+ /**
+ * Determine whether the source code has been requested via {@}source}
+ * @return boolean
+ */
+ function hasSource()
+ {
+ if (is_array($this->source)) return true;
+ return strlen($this->source);
+ }
+
+ /**
+ * @return string|array source code ready for highlighting
+ */
+ function getSource()
+ {
+ return $this->source;
+ }
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this function
+ * @param Converter
+ * @param string text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink('function ' . $this->name, $this->docblock->package);
+ }
+ return $c->getFunctionLink($this->name, $this->docblock->package, $this->path, $text);
+ }
+
+ /**
+ * Returns all functions in other packages that have the same name as this function
+ * @return mixed false or an array Format: (package => {@link parserFunction} of conflicting functions)
+ * @param Converter
+ */
+ function getConflicts(&$c)
+ {
+ $a = $c->proceduralpages->getFuncConflicts($this->name);
+ unset($a[$this->docblock->package]);
+ return $a;
+ }
+
+ /**
+ * Add all "global $var, $var2" declarations to this function
+ * @param array $globals Format: array(globalname1, globalname2,....)
+ */
+ function addGlobals($globals)
+ {
+ $this->globals = $globals;
+ }
+
+ /**
+ * Add all "static $var, $var2 = 6" declarations to this function
+ * @param array Format: array(varname1, varname2,...)
+ * @param array Format: array(default val of var 1, default val of var 2,...) if var 1 has no default, array(default val of var 2,...)
+ */
+ function addStatics($static,$vals)
+ {
+ if (count($static))
+ {
+ $this->statics = array();
+ for($i=0;$i<count($static);$i++)
+ {
+ if (isset($static[$i]))
+ {
+ $a = '';
+ if (isset($vals[$i])) $a = $vals[$i];
+ $this->statics[] = array('name' => $static[$i],'val' => $a);
+ }
+ }
+ }
+ }
+
+ /**
+ * @return string default value of param $name
+ * @param string
+ */
+ function getParam ($name)
+ {
+ if (!isset($this->params[$name])) return false;
+ $test = $this->params[$name];
+ if ($test[1])
+ {
+ return $this->params[$name];
+ } else
+ {
+ return false;
+ }
+ }
+
+ /**
+ * @return array format: array(array(paramname, default value),...)
+ */
+ function listParams ()
+ {
+ if (isset($this->params))
+ {
+ $ret = array();
+ if ($this->params)
+ foreach($this->params as $key => $val)
+ {
+ if ($val[1])
+ {
+ $arr = array($key,$val[0]);
+ if (isset($val[2]))
+ {
+ $arr[2] = $val[2];
+ }
+ $ret[] = $arr;
+ } else
+ {
+ $arr = array($key,false);
+ if (isset($val[2]))
+ {
+ $arr[2] = $val[2];
+ }
+ $ret[] = $arr;
+ }
+ }
+ return $ret;
+ } else {
+ return array();
+ }
+ }
+
+ /**
+ * @return array format: array(array(index, globalname),...)
+ */
+ function listGlobals ()
+ {
+ if (isset($this->globals))
+ {
+ $ret = array();
+ if ($this->globals)
+ foreach($this->globals as $key => $val)
+ {
+ $ret[] = array($key,$val);
+ }
+ return $ret;
+ } else {
+ return array();
+ }
+ }
+
+ /**
+ * @return array format: array(array(static var name, static var default value),...)
+ */
+ function listStatics ()
+ {
+ if (isset($this->statics))
+ {
+ $ret = array();
+ if ($this->statics)
+ foreach($this->statics as $key => $val)
+ {
+ $ret[] = array($val['name'],$val['val']);
+ }
+ return $ret;
+ } else {
+ return array();
+ }
+ }
+
+ /**
+ * sets {@link $returnsreference} to true
+ */
+ function setReturnsReference()
+ {
+ $this->returnsreference = true;
+ }
+
+ /**
+ * @return boolean returns value of {@link $returnsreference}
+ */
+ function getReturnsReference()
+ {
+ return $this->returnsreference;
+ }
+
+ /**
+ * Get a human-friendly description of the function call
+ *
+ * takes declaration like:
+ * <code>
+ * /** @returns string ... {rest of docblock}
+ * function &func($param1, $param2 = 6,
+ * $param3 = array('20',9 => "heroo"))
+ * {...}
+ * </code>
+ * and returns:
+ * string &func( $param1, [$param2 = 6], [$param3 = array('20',9 => "heroo")] )
+ * @return string stylized function declaration
+ */
+ function getFunctionCall()
+ {
+ $a = '';
+ if ($this->getReturnsReference()) $a = '&';
+ $function_call = $a.$this->getName() . " ( ";
+ $tmp = 0;
+ foreach($this->listParams() as $param)
+ {
+ if ($tmp == 0)
+ {
+ $tmp = 1;
+ } else {
+ $function_call .= ", ";
+ }
+ if ($param[1] !== false)
+ {
+ $function_call .= "[$param[0] = $param[1]]";
+ } else {
+ $function_call .= $param[0];
+ }
+ $update_params[] = $param[0];
+ }
+ $function_call .= " )";
+ return $function_call;
+ }
+
+ /**
+ * Like getFunctionCall(), but has no English or pre-determined formatting.
+ *
+ * Much more flexible.
+ * @return array Format:
+ * <code>
+ * array('name' => function name,
+ * 'returnsref' => boolean if declared as "function &name()"
+ * 'params' => array('type' => data type of parameter,
+ * 'description' => from @param tag,
+ * 'name' => variable name,
+ * 'default' => default value if any))
+ * </code>
+ * @see getFunctionCall()
+ */
+ function getIntricateFunctionCall($converter,$paramtags)
+ {
+ $a = array();
+ if ($this->getReturnsReference()) $a['returnsref'] = true;
+ $a['name'] = $converter->type_adjust($this->getName());
+ $c = $this->listParams();
+ foreach($c as $param)
+ {
+ $b = array();
+ $b['type'] = 'mixed';
+ if (isset($paramtags[$param[0]]))
+ {
+ $b['type'] = $paramtags[$param[0]]['datatype'];
+ $b['description'] = $paramtags[$param[0]]['data'];
+ unset($paramtags[$param[0]]);
+ } elseif(isset($paramtags[substr($param[0],1)]))
+ {
+ $b['type'] = $paramtags[substr($param[0],1)]['datatype'];
+ $b['description'] = $paramtags[substr($param[0],1)]['data'];
+ unset($paramtags[substr($param[0],1)]);
+ }
+ if (isset($param[2]))
+ {
+ $b['type'] = $param[2];
+ }
+ $b['name'] = $param[0];
+ $b['default'] = $param[1];
+ $b['hasdefault'] = ($param[1] !== false);
+ $a['params'][] = $b;
+ }
+ // @param tags that don't correspond to actual parameters (like extra function values)
+ if (count($paramtags))
+ {
+ foreach($paramtags as $param)
+ {
+ $b = array();
+ $b['type'] = $param['datatype'];
+ $b['description'] = $param['data'];
+ $b['name'] = $param['var'];
+ $b['default'] = '';
+ $b['hasdefault'] = false;
+ $a['params'][] = $b;
+ }
+ }
+ return $a;
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserClass extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'class'
+ */
+ var $type = 'class';
+ /** @var string
+ * @see parserPage::$sourceLocation */
+ var $sourceLocation = '';
+ /**
+ * @var mixed false or contents of extends clause in class declaration
+ */
+ var $extends = false;
+ /**
+ * @var array a list of interfaces this class implements
+ */
+ var $_implements = array();
+ /**
+ * @var array a list of interfaces this class implements
+ * @access private
+ */
+ var $_modifiers = false;
+ /**
+ * @var boolean determines whether a class is considered to be an interface
+ * @access private
+ */
+ var $_isInterface = false;
+ /**
+ * Format: array(file, parent) where parent class is found or false if no parent
+ * @var mixed
+ */
+ var $parent = false;
+ /**
+ * Used to determine whether a class should be ignored or not. Helps maintain integrity of parsing
+ * @var boolean
+ * @see Classes::getParentClass()
+ */
+ var $ignore = false;
+
+ /**
+ * @var string same as {@link parserElement::$path}
+ */
+ var $curfile = false;
+ /**
+ * @var tutorialLink|false either a link to the tutorial associated with this class, or false
+ */
+ var $tutorial = false;
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function getModifiers()
+ {
+ return $this->_modifiers;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function setModifiers($m)
+ {
+ $this->_modifiers = $m;
+ }
+
+ /**
+ * @param parserTutorial
+ * @param Converter
+ */
+ function addTutorial($t,&$c)
+ {
+ $this->tutorial = new tutorialLink;
+ $this->tutorial->addLink('',$t->path,$t->name,$t->package,$t->subpackage,$t->getTitle($c));
+ }
+
+ /**
+ * Get the associated tutorial for this class, if any
+ * @tutorial tutorials.pkg
+ * @return parserTutorial
+ */
+ function getTutorial()
+ {
+ return $this->tutorial;
+ }
+
+ /**
+ * Returns all classes in other packages that have the same name as this class
+ * @return mixed false or an array Format: (package => {@link parserClass} of conflicting classes)
+ * @param Converter
+ */
+ function getConflicts(&$c)
+ {
+ $a = $c->classes->getConflicts($this->name);
+ unset($a[$this->docblock->package]);
+ return $a;
+ }
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this class
+ * @param Converter
+ * @param string text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink('object ' . $this->name, $this->docblock->package);
+ }
+ return $c->getClassLink($this->name, $this->docblock->package, $this->curfile, $text);
+ }
+
+ /**
+ * @param string parent class name
+ * @param string parent class file
+ * @param Classes {@link Classes} object currently calling setParent
+ * @see Classes::setClassParent()
+ */
+
+ function setParent($p,$f, &$c)
+ {
+ $this->parent = array($f, $p);
+ $p = $c->getClass($p, $f);
+ // inherit package if no @package tag is in the docblock, fixes 591396
+ if (!$this->docblock->getExplicitPackage())
+ {
+ $this->docblock->package = $p->docblock->package;
+ }
+ if ($this->docblock->package == $p->docblock->package)
+ {
+ if ($this->docblock->subpackage == '')
+ $this->docblock->subpackage = $p->docblock->subpackage;
+ }
+ $author = $p->docblock->getKeyword('author');
+ $version = $p->docblock->getKeyword('version');
+ $copyright = $p->docblock->getKeyword('copyright');
+ // inherit tags
+ if (!$this->docblock->getKeyword('author'))
+ {
+ if ($author && !is_array($author)) $author = array($author);
+ if ($author) $this->docblock->tags['author'] = $author;
+ }
+ if (!$this->docblock->getKeyword('version'))
+ {
+ if ($version && !is_array($version)) $version = array($version);
+ if ($version) $this->docblock->tags['version'] = $version;
+ }
+ if (!$this->docblock->getKeyword('copyright'))
+ {
+ if ($copyright && !is_array($copyright)) $copyright = array($copyright);
+ if ($copyright) $this->docblock->tags['copyright'] = $copyright;
+ }
+ if (!$this->docblock->sdesc)
+ {
+ $this->docblock->setShortDesc($p->docblock);
+ $this->docblock->setDesc($p->docblock);
+ } else
+ {
+ if ($this->docblock->hasInheritDoc())
+ {
+ $this->docblock->replaceInheritDoc($p->docblock);
+ }
+ }
+ }
+
+ /**
+ * @param string $par parent class name (used by {@link Classes::setClassParent()} if parent class not found
+ */
+ function setParentNoClass($par)
+ {
+ $this->parent = $par;
+ }
+
+ /**
+ * Use this method to set the type of class to be an interface
+ */
+ function setInterface()
+ {
+ $this->_isInterface = true;
+ }
+
+ /**
+ * @return boolean true if this is an interface class
+ */
+ function isInterface()
+ {
+ return $this->_isInterface;
+ }
+
+ /**
+ * Use this method to set access modifiers for a class
+ * @param array
+ */
+ function setAccessModifiers($modifiers)
+ {
+ $this->_modifiers = $modifiers;
+ }
+
+ /**
+ * retrieve object that represents the parent class
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return mixed returns the {@link parserClass} representation of the parent class, or false if no parent class
+ */
+ function &getParent(&$c)
+ {
+ $a = false;
+ if (!$this->parent) return $a;
+ if (is_array($this->parent))
+ {
+ return $c->classes->getClass($this->parent[1],$this->parent[0]);
+ } else return $this->parent;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of method objects
+ */
+ function getMethods(&$c)
+ {
+ return $c->classes->getMethods($this->name,$this->curfile);
+ }
+
+ /**
+ * @return mixed {@link parserMethod} or false if not found
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param string method name in this class
+ */
+ function getMethod(&$c, $name)
+ {
+ return $c->classes->getMethod($this->name,$this->curfile,$name);
+ }
+
+ /**
+ * @return mixed {@link parserVar} or false if not found
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param string var name in this class
+ */
+ function getVar(&$c, $name)
+ {
+ return $c->classes->getVar($this->name,$this->curfile,$name);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of method name strings
+ */
+ function getMethodNames(&$c)
+ {
+ if (!$c->classes->hasMethods($this->curfile, $this->name)) return array();
+ $arr = array();
+ $arr1 = $this->getMethods($c);
+ for($i=0; $i < count($arr1); $i++)
+ {
+ $arr[] = $arr1[$i]->name;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param string method name
+ * @return boolean whether this class has a method of name $name
+ */
+ function hasMethod(&$c,$name)
+ {
+ return $c->classes->hasMethod($this->name, $this->curfile, $name);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param string var name
+ * @return boolean whether this class has a var of name $name
+ */
+ function hasVar(&$c,$name)
+ {
+ return $c->classes->hasVar($this->name, $this->curfile, $name);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param string class constant name
+ * @return boolean whether this class has a constant of name $name
+ */
+ function hasConst(&$c,$name)
+ {
+ return $c->classes->hasConst($this->name, $this->curfile, $name);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of var objects
+ */
+ function getVars(&$c)
+ {
+ return $c->classes->getVars($this->name,$this->curfile);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of const objects
+ */
+ function getConsts(&$c)
+ {
+ return $c->classes->getConsts($this->name,$this->curfile);
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of var name strings
+ */
+ function getVarNames(&$c)
+ {
+ if (!$c->classes->hasVars($this->curfile, $this->name)) return array();
+ $arr = array();
+ $arr1 = $this->getVars($c);
+ for($i=0; $i < count($arr1); $i++)
+ {
+ $arr[] = $arr1[$i]->name;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array returns a simple array of const name strings
+ */
+ function getConstNames(&$c)
+ {
+ if (!$c->classes->hasConsts($this->curfile, $this->name)) return array();
+ $arr = array();
+ $arr1 = $this->getConsts($c);
+ for($i=0; $i < count($arr1); $i++)
+ {
+ $arr[] = $arr1[$i]->name;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param boolean determines whether overriden methods should be included in the list of inherited methods
+ * @return array returns an array of methods by parent classname array(name => array(method1,method2..),name2 => array(method1....))
+ */
+ function getInheritedMethods(&$c,$override = false)
+ {
+ $x = $this;
+ $methods = array();
+ $arr = array();
+ while ($x->parent && is_array($x->parent))
+ {
+ $methods = array_merge($methods,$x->getMethodNames($c));
+ $par = $x->getParent($c);
+ $parmethodnames = $par->getMethodNames($c);
+ $parmethods = $par->getMethods($c);
+ for($i=0; $i<count($parmethodnames); $i++)
+ {
+ if ($override)
+ {
+ if (!in_array($parmethodnames[$i],$methods))
+ {
+ // fix for bug 587733
+ if ($parmethods[$i]->docblock && $parmethods[$i]->docblock->hasaccess && !$c->parseprivate && $parmethods[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $methods[] = $parmethodnames[$i];
+ $arr[$par->getName()]['methods'][] = $parmethods[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ } else
+ {
+ // fix for bug 587733
+ if ($parmethods[$i]->docblock && $parmethods[$i]->docblock->hasaccess && !$c->parseprivate && $parmethods[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $arr[$par->getName()]['methods'][] = $parmethods[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ }
+ $x = &$par;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param boolean determines whether overriden vars should be included in the list of inherited vars
+ * @return array returns an array of vars by parent classname array(name => array(var1,var1..),name2 => array(var1....))
+ */
+ function getInheritedVars(&$c,$override = true, $vars = false)
+ {
+ $x = $this;
+ $vars = array();
+ $arr = array();
+ while ($x->parent && is_array($x->parent))
+ {
+ $vars = array_merge($vars,$x->getVarNames($c));
+ $par = $x->getParent($c);
+ $parvarnames = $par->getVarNames($c);
+ $parvars = $par->getVars($c);
+ for($i=0; $i<count($parvarnames); $i++)
+ {
+ if ($override)
+ {
+ if (!in_array($parvarnames[$i],$vars))
+ {
+ // fix for bug 587733
+ if ($parvars[$i]->docblock && $parvars[$i]->docblock->hasaccess && !$c->parseprivate && $parvars[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $vars[] = $parvarnames[$i];
+ $arr[$par->getName()]['vars'][] = $parvars[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ } else
+ {
+ // fix for bug 587733
+ if ($parvars[$i]->docblock && $parvars[$i]->docblock->hasaccess && !$c->parseprivate && $parvars[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $arr[$par->getName()]['vars'][] = $parvars[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ }
+ $x = &$par;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @param boolean determines whether overriden vars should be included in the list of inherited vars
+ * @return array returns an array of consts by parent classname array(name => array(const1,const2..),name2 => array(const1....))
+ */
+ function getInheritedConsts(&$c,$override = false, $consts = false)
+ {
+ $x = $this;
+ $consts = array();
+ $arr = array();
+ while ($x->parent && is_array($x->parent))
+ {
+ $consts = array_merge($consts,$x->getConstNames($c));
+ $par = $x->getParent($c);
+ $parvarnames = $par->getConstNames($c);
+ $parvars = $par->getConsts($c);
+ for($i=0; $i<count($parvarnames); $i++)
+ {
+ if ($override)
+ {
+ if (!in_array($parvarnames[$i],$consts))
+ {
+ // fix for bug 587733
+ if ($parvars[$i]->docblock && $parvars[$i]->docblock->hasaccess && !$c->parseprivate && $parvars[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $consts[] = $parvarnames[$i];
+ $arr[$par->getName()]['consts'][] = $parvars[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ } else
+ {
+ // fix for bug 587733
+ if ($parvars[$i]->docblock && $parvars[$i]->docblock->hasaccess && !$c->parseprivate && $parvars[$i]->docblock->tags['access'][0]->value == 'private')
+ {
+ continue;
+ }
+ $arr[$par->getName()]['consts'][] = $parvars[$i];
+ $arr[$par->getName()]['file'] = $par->curfile;
+ }
+ }
+ $x = &$par;
+ }
+ return $arr;
+ }
+
+ /**
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array Format: array(parentclassname => parserClass/false if no parent, parentclassname2 => ...)
+ */
+ function getParentClassTree(&$c)
+ {
+ $result = array();
+ $result[$this->name] = $arr = $this->getParent($c);
+ if (is_string($arr)) $result[$arr] = false;
+ while ($arr && is_object($arr))
+ {
+ $result[$arr->name] = $arr->getParent($c);
+ $arr = $arr->getParent($c);
+ if (is_string($arr)) $result[$arr] = false;
+ }
+ return $result;
+ }
+
+ /**
+ * returns a list of all child classes of this class
+ * @param Converter this function will not work before the Conversion stage of parsing
+ * @return array Format: array(parserClass child1,parserClass child2,...)
+ */
+ function getChildClassList(&$c)
+ {
+ $list = array();
+ $kids = $c->classes->getDefiniteChildren($this->name,$this->curfile);
+ if ($kids)
+ {
+ foreach($kids as $chile => $file)
+ {
+ $list[] = $c->classes->getClass($chile,$file);
+ }
+ }
+ return $list;
+ }
+
+ /**
+ * @param string
+ * @see $sourceLocation
+ */
+ function setSourceLocation($sl)
+ {
+ $this->sourceLocation = $sl;
+ }
+
+ /**
+ * @param Converter
+ * @param boolean
+ * @return string
+ * @see $sourceLocation
+ */
+ function getSourceLocation($c,$pearize = false)
+ {
+ global $_phpDocumentor_options;
+ if (!isset($this->sourceLocation)) return false;
+ if ($pearize)
+ {
+ $sl = $this->sourceLocation;
+ if (strpos($sl,'pear/'))
+ {
+ $sl = substr($sl,strpos($sl,'pear/') + 5);
+ return $sl;
+ } else
+ {
+ return $sl;
+ }
+ return $sl;
+ }
+ return $this->sourceLocation;
+ }
+
+ /**
+ * @param string
+ * @see $extends
+ */
+ function setExtends($extends)
+ {
+ $this->extends = $extends;
+ }
+
+ /**
+ * @param string
+ */
+ function addImplements($implements)
+ {
+ $this->_implements[] = $implements;
+ }
+
+ /**
+ * @return array
+ */
+ function getImplements()
+ {
+ return $this->_implements;
+ }
+
+ /**
+ * @return boolean
+ * @see $extends
+ */
+ function getExtends()
+ {
+ if (!isset($this->extends)) return false;
+ return $this->extends;
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserVar extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'var'
+ */
+ var $type = 'var';
+ /** @var string class that contains this var */
+ var $class = '';
+ /** @var array */
+ var $_modifiers;
+
+ /**
+ * @param string
+ */
+ function parserVar($class)
+ {
+ $this->class = $class;
+ }
+
+ /**
+ * Retrieve the class name
+ * @return string Class name that this var belongs to
+ */
+ function getClass()
+ {
+ return $this->class;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function getModifiers()
+ {
+ return $this->_modifiers;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function setModifiers($m)
+ {
+ $this->_modifiers = $m;
+ }
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this var
+ * @param Converter $c
+ * @param string $text text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink($this->class . '::' . $this->name, $this->docblock->package);
+ }
+ return $c->getVarLink($this->name, $this->class, $this->docblock->package, false, $text);
+ }
+
+ /**
+ * @param Converter
+ * @return mixed {@link parserVar} representing var this var overrides from the parent class, or false if none
+ */
+ function getOverrides(&$c)
+ {
+ $class = $c->classes->getClass($this->class,$this->path);
+ $par = $class->getParent($c);
+
+ while (is_object($par))
+ {
+ if ($par->hasVar($c,$this->name))
+ {
+ $var = $par->getVar($c,$this->name);
+ if (!($var->docblock && $var->docblock->hasaccess && !$c->parseprivate && $var->docblock->tags['access'][0]->value == 'private'))
+ return $var;
+ }
+ $par = $par->getParent($c);
+ }
+
+ return false;
+ }
+
+ /**
+ * @param Converter
+ * @return array an array of parserVars from ALL child classes that override this var
+ */
+ function getOverridingVars(&$c)
+ {
+ $class = $c->classes->getClass($this->class,$this->path);
+
+ return $this->getOverridingVarsForClass($c, $class);
+ }
+
+ /**
+ * @param Converter
+ * @param parserClass
+ * @return array an array of parserVars from ALL child classes that override this var in the given class
+ */
+ function getOverridingVarsForClass(&$c, &$class)
+ {
+ $vars = array();
+ if (!$class) return $meths;
+ $kids = $class->getChildClassList($c);
+ for($i=0; $i<count($kids); $i++)
+ {
+ if ($kids[$i]->hasVar($c, $this->name))
+ {
+ $var = $kids[$i]->getVar($c,$this->name);
+ if (!($var->docblock && $var->docblock->hasaccess && !$c->parseprivate && $var->docblock->tags['access'][0]->value == 'private'))
+ $vars[] = $var;
+ }
+
+ $vars = array_merge($vars, $this->getOverridingVarsForClass($c, $kids[$i]));
+ }
+ return $vars;
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.2.4
+ */
+class parserConst extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'const'
+ */
+ var $type = 'const';
+ /** @var string class that contains this var */
+ var $class = '';
+
+ /**
+ * @param string
+ */
+ function parserConst($class)
+ {
+ $this->class = $class;
+ }
+
+ /**
+ * Retrieve the class name
+ * @return string Class name that this var belongs to
+ */
+ function getClass()
+ {
+ return $this->class;
+ }
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this var
+ * @param Converter $c
+ * @param string $text text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink($this->class . '::'. $this->name, $this->docblock->package);
+ }
+ return $c->getConstLink($this->name, $this->class, $this->docblock->package, false, $text);
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserMethod extends parserFunction
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'method'
+ */
+ var $type = 'method';
+ /** @var boolean whether this method is a constructor */
+ var $isConstructor = false;
+ /** @var boolean whether this method is a destructor by PEAR standards */
+ var $isDestructor = false;
+ /** @var string class that contains this method */
+ var $class = '';
+ var $_modifiers = array();
+
+ /**
+ * @param string
+ */
+ function parserMethod($class)
+ {
+ $this->class = $class;
+ }
+
+ /**
+ * @param string
+ * @param string default value parsed from function definition
+ * @param boolean indicates whether this parameter has a default value
+ * @param null|string class type hint
+ */
+ function addParam($name, $value, $has_default = true, $typehint = null)
+ {
+ $this->params[$name] = array($value, $has_default);
+ if (isset($typehint))
+ {
+ $this->params[$name][2] = $typehint;
+ }
+ }
+
+ /**
+ * adds "constructor " to start of function call if {@link $isConstructor} is true
+ * @return string
+ * @see parent::getFunctionCall()
+ */
+ function getFunctionCall()
+ {
+ $a = parserFunction::getFunctionCall();
+ if ($this->isConstructor) $a = "constructor $a";
+ return $a;
+ }
+
+ function getIntricateFunctionCall($converter,$paramtags)
+ {
+ $a = parserFunction::getIntricateFunctionCall($converter,$paramtags);
+ if ($this->isConstructor) $a['constructor'] = true;
+ if ($this->isDestructor) $a['destructor'] = true;
+ return $a;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function getClass()
+ {
+ return $this->class;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function getModifiers()
+ {
+ return $this->_modifiers;
+ }
+
+ /**
+ * Return name of the class that contains this method
+ * @return string
+ */
+ function setModifiers($m)
+ {
+ $this->_modifiers = $m;
+ }
+
+ /**
+ * @param Converter
+ * @return mixed {@link parserMethod} representing method this method overrides from the parent class, or false if none
+ */
+ function getOverrides(&$c)
+ {
+ $class = $c->classes->getClass($this->class,$this->path);
+
+ $par = $class->getParent($c);
+
+ while (is_object($par))
+ {
+ if ($par->hasMethod($c,$this->name))
+ {
+ $meth = $par->getMethod($c,$this->name);
+ if (!($meth->docblock && $meth->docblock->hasaccess && !$c->parseprivate && $meth->docblock->tags['access'][0]->value == 'private'))
+ return $meth;
+ }
+
+ $par = $par->getParent($c);
+ }
+
+ return false;
+ }
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this method
+ * @param Converter $c
+ * @param string $text text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink($this->class . '::' . $this->name . '()', $this->docblock->package);
+ }
+ return $c->getMethodLink($this->name, $this->class, $this->docblock->package, false, $text);
+ }
+
+ /**
+ * Use this method to tell the parser that this method is the class constructor
+ */
+ function setConstructor()
+ {
+ $this->isConstructor = true;
+ }
+
+ /**
+ * Use this method to tell the parser that this method is the class constructor
+ */
+ function setDestructor()
+ {
+ $this->isDestructor = true;
+ }
+
+ /**
+ * @param Converter
+ * @return array an array of parserMethods from child classes that override this method
+ */
+ function getOverridingMethods(&$c)
+ {
+ $class = $c->classes->getClass($this->class,$this->path);
+
+ return $this->getOverridingMethodsForClass($c, $class);
+ }
+
+ /**
+ * @param Converter
+ * @param parserClass
+ * @return array an array of parserMethods from ALL child classes that override this method in the given class
+ */
+ function getOverridingMethodsForClass(&$c, &$class)
+ {
+ $meths = array();
+ if (!$class) return $meths;
+ $kids = $class->getChildClassList($c);
+ for($i=0; $i<count($kids); $i++)
+ {
+ if ($kids[$i]->hasMethod($c, $this->name))
+ {
+ $meth = $kids[$i]->getMethod($c,$this->name);
+ if (!($meth->docblock && $meth->docblock->hasaccess && !$c->parseprivate && $meth->docblock->tags['access'][0]->value == 'private'))
+ $meths[] = $meth;
+ }
+
+ $meths = array_merge($meths, $this->getOverridingMethodsForClass($c, $kids[$i]));
+ }
+ return $meths;
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserDefine extends parserElement
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'define'
+ */
+ var $type = 'define';
+
+ /**
+ * quick way to link to this element
+ * @return mixed converter-specific link to this define
+ * @param Converter $c
+ * @param string $text text to display for the link or false for default text
+ */
+ function getLink($c, $text = false, $returnobj = false)
+ {
+ if ($returnobj)
+ {
+ return $c->getLink('constant ' . $this->name, $this->docblock->package);
+ }
+ return $c->getDefineLink($this->name, $this->docblock->package, false, $text);
+ }
+
+ /**
+ * Returns all defines in other packages that have the same name as this define
+ * @return mixed false or an array Format: (package => {@link parserDefine} of conflicting defines)
+ * @param Converter
+ */
+ function getConflicts(&$c)
+ {
+ $a = $c->proceduralpages->getDefineConflicts($this->name);
+ unset($a[$this->docblock->package]);
+ return $a;
+ }
+
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: ParserElements.inc,v 1.2 2005/11/28 07:27:59 cellog Exp $
+ */
+class parserPackagePage extends parserStringWithInlineTags
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'packagepage'
+ */
+ var $type = 'packagepage';
+ /** @var string */
+ var $package = 'default';
+
+ /**
+ * @param string
+ */
+ function parserPackagePage($package)
+ {
+ $this->package = $package;
+ }
+
+ /**
+ * @param Converter
+ */
+ function Convert(&$c)
+ {
+ return parent::Convert($c,false);
+ }
+}
+
+/**
+ * @package phpDocumentor
+ * @subpackage ParserElements
+ * @since 1.2
+ */
+class parserTutorial extends parserPackagePage
+{
+ /**
+ * Type is used by many functions to skip the hassle of if phpDocumentor_get_class($blah) == 'parserBlah'
+ * @var string always 'tutorial'
+ */
+ var $type = 'tutorial';
+ /** @var string */
+ var $package = 'default';
+ /**
+ * Either cls, pkg, or proc
+ * @var string
+ */
+ var $tutorial_type;
+ /**
+ * The documentable element this tutorial is linked to
+ *
+ * Can be a parserData, parserClass, or nothing for package/subpackage docs
+ */
+ var $linked_element;
+ /**
+ * path to the tutorial page
+ * @var string
+ */
+ var $path;
+ /**
+ * filename minus extension of this tutorial (used for @tutorial tag)
+ * @var string
+ */
+ var $name;
+ /** @var boolean */
+ var $_xml = true;
+ /**
+ * output from tutorialname.ext.ini
+ *
+ * an array generated by {@link phpDocumentor_parse_ini_file()} containing
+ * an index 'Linked Tutorials' with an array of tutorial names in the order
+ * they should appear. This is used to generate a linked list of tutorials like
+ * {@tutorial phpDocumentor/tags.pkg}
+ * @var array
+ */
+ var $ini = false;
+ /**
+ * link to the next tutorial in a document series, or false if none
+ * @var tutorialLink
+ */
+ var $next = false;
+ /**
+ * link to the previous tutorial in a document series, or false if none
+ * @var tutorialLink
+ */
+ var $prev = false;
+ /**
+ * link to the parent tutorial in a document series, or false if none
+ *
+ * This is used to generate an "Up" or "Home" link like the php manual.
+ * The parent is defined as a tutorial that has a parenttutorialname.ext.ini
+ * file and is not contained by any other tutorial's tutorialname.ext.ini
+ * @var tutorialLink
+ */
+ var $parent = false;
+ /**
+ * links to the child tutorials, or false if none
+ * @var array
+ */
+ var $children = false;
+
+ /**
+ * @param parserXMLDocBookTag top-level tag (<refentry> for 1.2.0)
+ * @param information about the tutorial file. Format:
+ *
+ * <pre>
+ * array('tutename' => tutorial name,
+ * 'path' => relative path of tutorial to tutorials/ directory
+ * 'ini' => contents of the tutorial .ini file, if any)
+ * </pre>
+ */
+ function parserTutorial($data, $info)
+ {
+ $this->value = $data;
+ $this->package = $info['package'];
+ $this->subpackage = $info['subpackage'];
+ $this->tutorial_type = $info['tutetype'];
+ $this->name = $info['tutename'];
+ $this->path = $info['path'];
+ $this->ini = $info['ini'];
+ }
+
+ /**
+ * Retrieve the title of the tutorial, or of any subsection
+ * @param Converter
+ * @param string which subsection to retrieve the title from, if any
+ * @uses parserXMLDocBookTag::getSubSection() retrieve the subsection to
+ * to get a title from
+ */
+ function getTitle(&$c,$subsection = '')
+ {
+ if (!empty($subsection))
+ {
+ $z = $this->value->getSubSection($c,$subsection);
+ if (!$z)
+ {
+ addWarning(PDERROR_TUTORIAL_SUBSECTION_NOT_FOUND,$this->name,$subsection);
+ return $subsection;
+ }
+ return $z->getTitle($c);
+ }
+ return $this->value->getTitle($c);
+ }
+
+ /**
+ * @param Converter
+ * @param boolean determines whether character data is postprocessed to be
+ * Converter-friendly or not.
+ */
+ function Convert(&$c, $postprocess = true)
+ {
+ return $this->value->Convert($c, $postprocess);
+ }
+
+ /**
+ * @uses $parent creates a link to the documentation for the parent tutorial
+ * @param parserTutorial
+ * @param Converter
+ */
+ function setParent($parent,&$c)
+ {
+ $this->parent = new tutorialLink;
+ $this->parent->addLink('', $parent->path, $parent->name, $parent->package, $parent->subpackage, $parent->getTitle($c));
+ }
+
+ /**
+ * @param array array of parserTutorials that have child tutorials
+ */
+ function isChildOf($parents)
+ {
+ foreach($parents as $i => $parent)
+ {
+ if ($parent->path == $this->path) continue;
+ if ($parent->ini && ($parent->package == $this->package) && ($parent->subpackage == $this->subpackage) && ($parent->tutorial_type == $this->tutorial_type))
+ {
+ foreach($parent->ini['Linked Tutorials'] as $child)
+ {
+ if ($child . '.' . $this->tutorial_type == $this->name) return true;
+ }
+ }
+ }
+ }
+
+ /**
+ * Retrieve converter-specific link to the parent tutorial's documentation
+ * @param Converter
+ */
+ function getParent(&$c)
+ {
+ if (!$this->parent) return false;
+ return $c->returnSee($this->parent);
+ }
+
+ /**
+ * @uses $next creates a link to the documentation for the next tutorial
+ * @param parserTutorial
+ * @param Converter
+ */
+ function setNext($next,&$c)
+ {
+ if (phpDocumentor_get_class($next) == 'tutoriallink') return $this->next = $next;
+ $this->next = new tutorialLink;
+ $this->next->addLink('', $next->path, $next->name, $next->package, $next->subpackage, $next->getTitle($c));
+ }
+
+ /**
+ * Retrieve converter-specific link to the next tutorial's documentation
+ * @param Converter
+ */
+ function getNext(&$c)
+ {
+ if (!$this->next) return false;
+ return $c->returnSee($this->next);
+ }
+
+ /**
+ * @uses $prev creates a link to the documentation for the previous tutorial
+ * @param parserTutorial
+ * @param Converter
+ */
+ function setPrev($prev,&$c)
+ {
+ if (phpDocumentor_get_class($prev) == 'tutoriallink') return $this->prev = $prev;
+ $this->prev = new tutorialLink;
+ $this->prev->addLink('', $prev->path, $prev->name, $prev->package, $prev->subpackage, $prev->getTitle($c));
+ }
+
+ /**
+ * Retrieve converter-specific link to the previous tutorial's documentation
+ * @param Converter
+ */
+ function getPrev(&$c)
+ {
+ if (!$this->prev) return false;
+ return $c->returnSee($this->prev);
+ }
+
+ /**
+ * Get a link to this tutorial, or to any subsection of this tutorial
+ * @param Converter
+ * @param boolean if true, returns a {@link tutorialLink} instead of a string
+ * @param string section name to link to
+ * @return string|tutorialLink
+ */
+ function getLink(&$c,$pure = false,$section = '')
+ {
+ $link = new tutorialLink;
+ $link->addLink($section, $this->path, $this->name, $this->package, $this->subpackage, $this->getTitle($c), $this->category);
+ if ($pure) return $link;
+ return $c->returnSee($link);
+ }
+}
+
+?>
\ No newline at end of file |