diff options
| author | xue <> | 2006-06-19 18:38:29 +0000 |
|---|---|---|
| committer | xue <> | 2006-06-19 18:38:29 +0000 |
| commit | 588727c7e2b8954ec3dbde293cf4c4d68b119f9b (patch) | |
| tree | fdcc16181a20335547953ccf1550e0006c11bf28 /buildscripts/PhpDocumentor/phpDocumentor/Classes.inc | |
| parent | 127f78a4db3cc0fbbbb92f5b1abcfdce4a9af93b (diff) | |
Merge from 3.0 branch till 1185.
Diffstat (limited to 'buildscripts/PhpDocumentor/phpDocumentor/Classes.inc')
| -rw-r--r-- | buildscripts/PhpDocumentor/phpDocumentor/Classes.inc | 1068 |
1 files changed, 1068 insertions, 0 deletions
diff --git a/buildscripts/PhpDocumentor/phpDocumentor/Classes.inc b/buildscripts/PhpDocumentor/phpDocumentor/Classes.inc new file mode 100644 index 00000000..d4f29745 --- /dev/null +++ b/buildscripts/PhpDocumentor/phpDocumentor/Classes.inc @@ -0,0 +1,1068 @@ +<?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. |
+// +------------------------------------------------------------------------+
+//
+
+/**
+ * Intermediate class parsing structure.
+ * @package phpDocumentor
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: Classes.inc,v 1.1 2005/10/17 18:36:55 jeichorn Exp $
+ */
+/**
+ * Intermediate class parsing structure.
+ *
+ * The {@link phpDocumentor_IntermediateParser} class uses this class and its
+ * cousin, {@link ProceduralPages} to organize all parsed source code elements.
+ * Data is fed to each immediately after it is parsed, and at conversion time,
+ * everything is organized.
+ *
+ * The Classes class is responsible for all inheritance, including resolving
+ * name conflicts between classes, determining which classes extend other
+ * classes, and is responsible for all inheritance of documentation.
+ * {@internal
+ * This structure parses classes, vars and methods by file, and then iterates
+ * over the class tree to set up inheritance. The {@link Inherit()}
+ * method is the meat of the class, and processes the class trees from root to
+ * branch, ensuring that parsing order is unimportant.}}
+ * @package phpDocumentor
+ * @author Greg Beaver <cellog@users.sourceforge.net>
+ * @since 1.0rc1
+ * @version $Id: Classes.inc,v 1.1 2005/10/17 18:36:55 jeichorn Exp $
+ */
+class Classes
+{
+ /**#@+
+ * @access private
+ */
+ /**
+ * file being parsed, used in every add function to match up elements with
+ * the file that contains them
+ *
+ * This variable is used during parsing to associate class elements added
+ * to the data structures that contain them with the file they reside in
+ * @see addClass(), addMethod(), addVar(), nextFile()
+ * @var string
+ */
+ var $curfile;
+ /**
+ * class being parsed, used to match up methods and vars with their parent
+ * class
+ *
+ * This variable is used during parsing to associate class elements added
+ * to the data structures that contain them with the file they reside in
+ * @see addMethod(), addVar()
+ * @var string
+ */
+ var $curclass;
+
+ /**
+ * Used when a definite match is made between a parent class and a child
+ * class
+ *
+ * This variable is used in post-parsing.
+ *
+ * Format: array(parent => array(parentfile => array(child => childfile)))
+ * @var array
+ */
+ var $definitechild;
+ /**
+ * array of parsed classes organized by the name of the file that contains
+ * the class.
+ *
+ * Format:
+ * array(filename => array(classname => {@link parserClass}))
+ * @var array
+ */
+ var $classesbyfile = array();
+ /**
+ * array of file names organized by classes that are in the file.
+ *
+ * This structure is designed to handle name conflicts. Two files can
+ * contain classes with the same name, and this array will record both
+ * filenames to help control linking and inheritance errors
+ *
+ * Format:<pre>
+ * array(classname => array(name of file containing classname,
+ * name of file 2 containing classname...)</pre>
+ * @var array
+ */
+ var $classesbynamefile = array();
+ /**
+ * array of parsed methods organized by the file that contains them.
+ *
+ * Format:<pre>
+ * array(filename => array(classname => array({@link parserMethod} 1,
+ * {@link parserMethod} 2,...))</pre>
+ * @var array
+ */
+ var $methodsbyfile = array();
+ /**
+ * array of parsed vars organized by the file that contains them.
+ *
+ * Format:
+ * array(filename => array(classname => array({@link parserVar} 1, {@link parserVar} 2,...))
+ * @var array
+ */
+ var $varsbyfile = array();
+ /**
+ * array of parsed class constants organized by the file that contains them.
+ *
+ * Format:
+ * array(filename => array(classname => array({@link parserConst} 1, {@link parserConst} 2,...))
+ * @var array
+ */
+ var $constsbyfile = array();
+ /**
+ * keeps track of extend declarations by file, used to find inheritance
+ *
+ * Format:
+ * array(filename => array(classname => parentclassname))
+ * @var array
+ */
+ var $extendsbyfile = array();
+ /**
+ * Keeps track of child classes by file.
+ * Since phpDocumentor can document collections of files that contain name
+ * conflicts (PHP would give a fatal error), it
+ * is impossible to assume a class that declares "extends foo" necessarily
+ * extends the class foo in file X. It could be an
+ * extended class of class foo in file Y. Because of this, phpDocumentor
+ * relies on packaging to resolve the name conflict
+ * This array keeps track of the packages of a child class
+ *
+ * Format:
+ * array(parentclassname => array(filename => array(childclassname =>
+ * array(packagename, packagename)))
+ * @var array
+ */
+ var $classchildrenbyfile = array();
+ /**
+ * Keeps track of class packages found in a file.
+ * This is used in {@link getParentClass()} to determine the number of
+ * packages in a file, in order to resolve inheritance issues
+ * Format: array(filename => array(packagename1, packagename2,...))
+ * @var array
+ */
+ var $classpackagebyfile = array();
+ /**
+ * a tree of class inheritance by name.
+ *
+ * format:<pre>
+ * array(childname => parentname,
+ * childname1 => parentname1,
+ * rootname => 0, ...
+ * )</pre>
+ * @var array
+ * @see Converter::generateSortedClassTreeFromClass()
+ */
+ var $classparents = array();
+ /**
+ * Keeps track of package and subpackage for each class name, organized
+ * by package
+ *
+ * Format:<pre>
+ * array(classname => array(path => array(package,subpackage),
+ * path2 => array(package,subpackage),...))</pre>
+ * @var array
+ */
+ var $classpathpackages = array();
+ /**
+ * used to delete duplicates in the same package to avoid documentation errors
+ *
+ * Specifically used in {@link Converter::checkKillClass()}
+ */
+ var $killclass = array();
+ /**
+ * array of methods by package and class
+ *
+ * format:<pre>
+ * array(packagename =>
+ * array(classname =>
+ * array(methodname1 => {@link parserMethod} class,
+ * methodname2 => {@link parserMethod} class,...)
+ * )
+ * )
+ * )</pre>
+ * @var array
+ * @see Converter
+ */
+ var $methods = array();
+
+ /**
+ * array of class variables by package and class
+ *
+ * format:<pre>
+ * array(packagename =>
+ * array(classname =>
+ * array(variablename1 => {@link parserVar} class,
+ * variablename2 => {@link parserVar} class,...
+ * )
+ * )
+ * )</pre>
+ * @var array
+ * @see Converter
+ */
+ var $vars = array();
+
+ /**
+ * array of class variables by package and class
+ *
+ * format:<pre>
+ * array(packagename =>
+ * array(classname =>
+ * array(constname1 => {@link parserConst} class,
+ * constname2 => {@link parserConst} class,...
+ * )
+ * )
+ * )</pre>
+ * @var array
+ * @see Converter
+ */
+ var $consts = array();
+ /**
+ * Reverse class_packages_by_file, used to prevent duplicates
+ * @var array Format: array(packagename => 1)
+ */
+ var $revcpbf = array();
+ /**
+ * All classes with no parents (no extends clause) are tracked in this array
+ * by the file that contains them.
+ *
+ * Format:<pre>
+ * array(classname => array(name of file1 that contains root classname,
+ * name of file2 that contains root classname,...))</pre>
+ * @var array
+ */
+ var $roots = array();
+
+ /**
+ * array of all files that contain classes with the same name
+ * @var array Format: (classname => array(path1, path2,...))
+ */
+ var $potentialclassconflicts = array();
+
+ /**
+ * array of all inter-package name conflicts of classes
+ *
+ * This array allows documentation of PHP namespace conflicts that would
+ * occur should a user try to include these files in the same file
+ * @var array Format: (classname => array(path1, path2,...))
+ */
+ var $classconflicts = array();
+ /**#@-*/
+ /**
+ * While parsing, add a class to the list of parsed classes
+ *
+ * sets up the {@link $classesbyfile, $classesbynamefile, $extendsbyfile},
+ * {@link $classchildrenbyfile, $roots} arrays, and sets {@link $curclass}
+ * @param parserClass &$element element is a {@link parserClass}
+ * @uses addPackageToFile() marks the current class's package as being
+ * present in a file
+ */
+ function addClass(&$element)
+ {
+ $this->curclass = $element->getName();
+ $element->curfile = $this->curfile;
+ if (isset($this->classesbyfile[$this->curfile][$this->curclass]))
+ {
+ addWarning(PDERROR_ELEMENT_IGNORED,'class',$this->curclass,$this->curfile);
+ $this->curclass = false;
+ return;
+ }
+ $this->classesbyfile[$this->curfile][$this->curclass] = $element;
+ $this->classesbynamefile[$this->curclass][] = $this->curfile;
+ $this->extendsbyfile[$this->curfile][$this->curclass] = $element->getExtends();
+ $this->classchildrenbyfile[$element->getExtends()][$this->curfile][$this->curclass][] = $element->docblock->package;
+ if ($element->docblock->getExplicitPackage())
+ $this->addPackageToFile($element->docblock->package);
+ if (!$element->getExtends())
+ {
+ $this->roots[$this->curclass][] = $this->curfile;
+ }
+ }
+
+ /**
+ * While parsing, add a method to the list of parsed methods
+ *
+ * sets up the {@link $methodsbyfile} array using {@link $curfile} and
+ * {@link $curclass}
+ * @param parserMethod &$element element is a {@link parserMethod}
+ */
+ function addMethod(&$element)
+ {
+ if (!$this->curclass) return;
+ $this->methodsbyfile[$this->curfile][$this->curclass][] = $element;
+ }
+
+ /**
+ * While parsing, add a variable to the list of parsed variables
+ *
+ * sets up the {@link $varsbyfile} array using {@link $curfile} and {@link $curclass}
+ * @param parserVar &$element element is a {@link parserVar}
+ */
+ function addVar(&$element)
+ {
+ if (!$this->curclass) return;
+ $this->varsbyfile[$this->curfile][$this->curclass][] = $element;
+ }
+
+ /**
+ * While parsing, add a variable to the list of parsed variables
+ *
+ * sets up the {@link $constsbyfile} array using {@link $curfile} and {@link $curclass}
+ * @param parserConst &$element element is a {@link parserConst}
+ */
+ function addConst(&$element)
+ {
+ if (!$this->curclass) return;
+ $this->constsbyfile[$this->curfile][$this->curclass][] = $element;
+ }
+
+ /**
+ * Prepare to parse a new file
+ *
+ * sets {@link $curfile} to $file and {@link $curclass} to false (no class being parsed)
+ * @param string $file file currently being parsed
+ */
+ function nextFile($file)
+ {
+ $this->curfile = $file;
+ $this->curclass = false;
+ }
+
+ /**
+ * Mark a package as being used in a class
+ *
+ * {@source}
+ * @param string $package package name
+ */
+ function addPackageToFile($package)
+ {
+ if (!isset($this->revcpbf[$this->curfile][$package]))
+ $this->classpackagebyfile[$this->curfile][] = $package;
+ $this->revcpbf[$this->curfile][$package] = 1;
+ }
+
+ /**
+ * Find the parent class of $class, and set up structures to note this fact
+ *
+ * Modifies the {@link parserClass} element in {@link $classesbyfile} to use
+ * the parent's package, and inherit methods/vars
+ * @param string $class child class to find parent class
+ * @param string $file file child class is located in
+ * @uses $definitechild if a match is made between a parent class and parameter
+ * $class in file $file, then definitechild is set here
+ * @uses getParentClass() to find the parent class
+ */
+ function setClassParent($class,$file)
+ {
+ if (is_array($par = $this->getParentClass($class,$file)))
+ {
+// phpDocumentor_out("$file class $class extends ".$par[1]." file ".$par[0]."\n");
+ $this->classesbyfile[$file][$class]->setParent($par[1],$par[0],$this);
+ $this->definitechild[$par[1]][$par[0]][$class] = $file;
+ } else
+ {
+ $this->classesbyfile[$file][$class]->setParentNoClass($par);
+ }
+ }
+
+ /**
+ * Main processing engine for setting up class inheritance.
+ *
+ * This function uses {@link $roots} to traverse the inheritance tree via
+ * {@link processChild()} and returns the data structures
+ * phpDocumentor_IntermediateParser needs to convert parsed data
+ * to output using {@link phpDocumentor_IntermediateParser::Convert()}
+ * @param phpDocumentor_IntermediateParser
+ * @uses processChild() set up inheritance
+ */
+ function Inherit(&$render)
+ {
+ phpDocumentor_out("\nProcessing Class Inheritance\n\n");
+ flush();
+ phpDocumentor_out("\nProcessing Root Trees\n\n");
+ flush();
+ foreach($this->roots as $class => $files)
+ {
+ for ($i=0; $i<count($files); $i++)
+ {
+ $this->processChild($render,$class,$files[$i]);
+ }
+ }
+ if (0)
+ foreach($this->classesbyfile as $i => $j)
+ {
+ foreach($j as $k => $m)
+ {
+ var_dump($i,$k);
+ if ($i == 'iConverter')
+ {
+ var_dump($j);
+ }
+ }
+ }
+ phpDocumentor_out("\nProcessing leftover classes (classes that extend root classes not found in the same package)\n");
+ flush();
+ foreach($this->classesbyfile as $i => $j)
+ {
+ foreach($j as $k => $m)
+ {
+ $this->processChild($render,$k,$i,true);
+ }
+ }
+ phpDocumentor_out("done processing leftover classes\n");
+ flush();
+ $this->setupClassConflicts();
+ }
+
+ /**
+ * Transfers actual conflicts from {@link $potentialClassconflicts} to
+ * {@link $classconflicts}
+ * @access private
+ * @uses $potentialclassconflicts transfers values to {@link $classconflicts}
+ */
+ function setupClassConflicts()
+ {
+ foreach($this->potentialclassconflicts as $class => $paths)
+ {
+ if (count($paths) - 1)
+ { //conflict
+ $package = array();
+ foreach($paths as $path)
+ {
+ // create a list of conflicting classes in each package
+ if (isset($this->classpathpackages[$class][$path]))
+ $package[$this->classpathpackages[$class][$path][0]][] = $path;
+ }
+ foreach($package as $pathpackages)
+ {
+ // if at least 2 functions exist in the same package, delete all but the first one and add warnings
+ if (count($pathpackages) - 1)
+ {
+ for($i=1; $i < count($pathpackages); $i++)
+ {
+ if (isset($this->classesbyfile[$pathpackages[$i]]))
+ {
+ addWarning(PDERROR_ELEMENT_IGNORED,'class',$class,$pathpackages[$i]);
+ $this->killClass($class,$pathpackages[$i]);
+ $oth = array_flip($paths);
+ unset($paths[$oth[$pathpackages[$i]]]);
+ }
+ }
+ }
+ }
+ $this->classconflicts[$class] = $paths;
+ }
+ }
+ }
+
+ /**
+ * If a package contains two classes with the same name, this function finds
+ * that conflict
+ *
+ * Returns the {@link $classconflicts} entry for class $class, minus its own path
+ * @return mixed returns false if no conflicts, or an array of paths containing conflicts
+ */
+ function getConflicts($class)
+ {
+ if (!isset($this->classconflicts[$class])) return false;
+ $a = array();
+ foreach($this->classconflicts[$class] as $conflict)
+ {
+ $a[$this->classesbyfile[$conflict][$class]->docblock->package] = $this->classesbyfile[$conflict][$class];
+ }
+ return $a;
+ }
+
+ /**
+ * sets up {@link $killclass} for use by Converter::checkKillClass()
+ * @access private
+ */
+ function killClass($class,$path)
+ {
+ $this->killclass[$class][$path] = true;
+ }
+
+ /**
+ * This function recursively climbs up the class tree, setting inherited
+ * information like package and adds the elements to phpDocumentor_IntermediateParser.
+ *
+ * Using structures defined in {@link Classes}, the function first sets package information,
+ * and then seeks out child classes.
+ * It uses 3 tests to determine whether a class is a child class.
+ * <ol>
+ * <li>child class is in the same file as the parent class and extends parent class</li>
+ * <li>child class is in a different file and specifies the parent's @package in its docblock</li>
+ * <li>child class is in a different file and is in a different @package, with one possible parent class</li>
+ * </ol>
+ * @param phpDocumentor_IntermediateParser &$render
+ * @param string $class class to process
+ * @param string $file name of file $class is located in
+ * @param boolean $furb flag used privately to control informational output while parsing
+ * (used when processing leftover classes in {@link Inherit()}
+ * @global string default package, usually "default"
+ */
+ function processChild(&$render,$class,$file,$furb = false)
+ {
+ global $phpDocumentor_DefaultPackageName;
+ if (isset($this->classesbyfile[$file][$class]->processed)) return;
+ $this->potentialclassconflicts[$class][] = $file;
+ if ($furb) phpDocumentor_out("Processing $class in file $file\n");
+ flush();
+ $this->classesbyfile[$file][$class]->processed = true;
+ $db = $this->classesbyfile[$file][$class];
+ $render->addUses($db,$file);
+ if (!$render->parsePrivate)
+ {
+ // if this class has an @access private, and parse private is disabled, remove it
+ if ($db->docblock->hasaccess)
+ {
+ $aaa = $db->docblock->getKeyword('access');
+ if (is_object($aaa) && $aaa->getString() == 'private')
+ {
+ if (isset($this->varsbyfile[$file]) && isset($this->varsbyfile[$file][$class]))
+ {
+ unset($this->varsbyfile[$file][$class]);
+ }
+ if (isset($this->methodsbyfile[$file]) && isset($this->methodsbyfile[$file][$class]))
+ {
+ unset($this->methodsbyfile[$file][$class]);
+ }
+ if (isset($this->constsbyfile[$file]) && isset($this->constsbyfile[$file][$class]))
+ {
+ unset($this->constsbyfile[$file][$class]);
+ }
+ $this->classesbyfile[$file][$class]->ignore = true;
+ // if this is a root class, remove it from the roots array
+ if (isset($this->roots[$class]))
+ foreach($this->roots[$class] as $i => $files)
+ {
+ // find the file kkey and unset
+ if ($files == $file) unset($this->roots[$class][$i]);
+ }
+ // if this is a child, remove it from the list of child classes of its parent
+ if ($db->getExtends()) unset($this->classchildrenbyfile[$db->getExtends()][$file]);
+ return;
+ }
+ }
+ }
+ if ($render->packageoutput)
+ {
+ if (!in_array($db->docblock->package,$render->packageoutput))
+ {
+ if (isset($this->varsbyfile[$file]) && isset($this->varsbyfile[$file][$class]))
+ {
+ unset($this->varsbyfile[$file][$class]);
+ }
+ if (isset($this->methodsbyfile[$file]) && isset($this->methodsbyfile[$file][$class]))
+ {
+ unset($this->methodsbyfile[$file][$class]);
+ }
+ if (isset($this->constsbyfile[$file]) && isset($this->constsbyfile[$file][$class]))
+ {
+ unset($this->constsbyfile[$file][$class]);
+ }
+ $this->classesbyfile[$file][$class]->ignore = true;
+ if (isset($this->roots[$class]))
+ foreach($this->roots[$class] as $i => $files)
+ {
+ if ($files == $file) unset($this->roots[$class][$i]);
+ }
+ if ($db->getExtends()) unset($this->classchildrenbyfile[$db->getExtends()][$file]);
+ return;
+ }
+ }
+ $this->setClassParent($class,$file);
+ $db = $this->classesbyfile[$file][$class];
+ if ($furb && !is_array($db->parent))
+ {
+// debug("furb adding $class $file to roots");
+ $this->roots[$class][] = $file;
+ }
+ // fix for 591396
+ if (!$db->docblock->getExplicitPackage())
+ {
+ $a = $render->proceduralpages->pagepackages[$file];
+ if ($a[0] != $phpDocumentor_DefaultPackageName)
+ {
+ // inherit page package
+ $this->classesbyfile[$file][$class]->docblock->package = $a[0];
+ }
+ }
+ if ($this->classesbyfile[$file][$class]->docblock->package == $render->proceduralpages->pagepackages[$file][0])
+ {
+ if ($this->classesbyfile[$file][$class]->docblock->subpackage == '')
+ $this->classesbyfile[$file][$class]->docblock->subpackage = $render->proceduralpages->pagepackages[$file][1];
+ }
+ $db = $this->classesbyfile[$file][$class];
+ $render->addPackageParent($db);
+ $render->addPageIfNecessary($file, $db);
+ if ($access = $db->docblock->getKeyword('access'))
+ {
+ if (!is_string($access) && is_object($access)) $access = $access->getString();
+ if (!is_string($access)) $access = 'public';
+ if (($access == 'private') && (!$render->parsePrivate))
+ {
+ if (isset($this->varsbyfile[$file]) && isset($this->varsbyfile[$file][$class]))
+ foreach($this->varsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->addKeyword('access','private');
+ $this->varsbyfile[$file][$class][$i] = $vr;
+ }
+ if (isset($this->methodsbyfile[$file]) && isset($this->methodsbyfile[$file][$class]))
+ foreach($this->methodsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->addKeyword('access','private');
+ $this->methodsbyfile[$file][$class][$i] = $vr;
+ }
+ if (isset($this->constsbyfile[$file]) && isset($this->constsbyfile[$file][$class]))
+ foreach($this->constsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->addKeyword('access','private');
+ $this->constsbyfile[$file][$class][$i] = $vr;
+ }
+ }
+ }
+ $this->classpathpackages[$class][$file] = array($db->docblock->package,$db->docblock->subpackage);
+ if ($db->docblock->getExplicitPackage())
+ $render->proceduralpages->addClassPackageToFile($file,$db->docblock->package,$db->docblock->subpackage);
+ $render->addElementToPage($db,$file);
+ if (isset($this->varsbyfile[$file]) && isset($this->varsbyfile[$file][$class]))
+ foreach($this->varsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->package = $db->docblock->package;
+ $vr->docblock->subpackage = $db->docblock->subpackage;
+ $render->addElementToPage($vr,$file);
+ $render->addUses($vr,$file);
+ $this->varsbyfile[$file][$class][$i] = $vr;
+ $this->vars[$db->docblock->package][$class][$vr->getName()] = $vr;
+ }
+ if (isset($this->methodsbyfile[$file]) && isset($this->methodsbyfile[$file][$class]))
+ foreach($this->methodsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->package = $db->docblock->package;
+ $vr->docblock->subpackage = $db->docblock->subpackage;
+ $render->addElementToPage($vr,$file);
+ $render->addUses($vr,$file);
+ $this->methodsbyfile[$file][$class][$i] = $vr;
+ $this->methods[$db->docblock->package][$class][$vr->getName()] = $vr;
+ }
+ if (isset($this->constsbyfile[$file]) && isset($this->constsbyfile[$file][$class]))
+ foreach($this->constsbyfile[$file][$class] as $i => $vr)
+ {
+ $vr->docblock->package = $db->docblock->package;
+ $vr->docblock->subpackage = $db->docblock->subpackage;
+ $render->addElementToPage($vr,$file);
+ $render->addUses($vr,$file);
+ $this->constsbyfile[$file][$class][$i] = $vr;
+ $this->methods[$db->docblock->package][$class][$vr->getName()] = $vr;
+ }
+ $this->classpackages[$class][] = array($db->docblock->package,$db->docblock->subpackage);
+ if (is_array($db->parent))
+ $this->classparents[$db->docblock->package][$class] = $db->parent[1];
+ else
+ $this->classparents[$db->docblock->package][$class] = $db->getExtends();
+ if (is_array($db->parent))
+ {
+ $z = $this->getClass($db->parent[1],$db->parent[0]);
+ $this->classchildren[$z->docblock->package][$db->parent[1]][] = $db;
+ }
+ if (isset($this->classchildrenbyfile[$class]))
+ {
+ foreach($this->classchildrenbyfile[$class] as $childfile => $other)
+ {
+ // test 1, inherits in same file (must be same package)
+ if ($childfile == $file)
+ {
+ foreach($other as $child => $packages)
+ {
+// debug("parent $class same file $child");
+ $this->processChild($render,$child,$childfile);
+ $x = $this->getClass($child,$childfile);
+ if ($x->docblock->package != $GLOBALS['phpDocumentor_DefaultPackageName'])
+ {
+ // child package need root for class trees
+ if ($x->docblock->package != $db->docblock->package)
+ {
+// debug("adding $child in $childfile 1");
+ $this->roots[$child][] = $childfile;
+ }
+ }
+ }
+ } else
+ {
+ // test 2, different file, same package
+ foreach($other as $child => $packages)
+ {
+ for($j=0; $j<count($packages); $j++)
+ {
+ if ($this->classesbyfile[$file][$class]->docblock->package == $packages[$j])
+ {
+ $this->processChild($render,$child,$childfile);
+// debug("$childfile diff file $child, parent $class, same package ".$packages[$j]);
+ } else
+ {
+ // test 3, different file, different package, only 1 parent is possible
+ if (isset($this->classesbynamefile[$child]))
+ {
+ // 1 possible parent
+ if (count($this->classesbynamefile[$class]) == 1)
+ {
+// debug("$childfile diff file $child, diff package, 1 possible parent root $class");
+ $this->processChild($render,$child,$childfile);
+ $x = $this->getClass($child,$childfile);
+ if ($x->docblock->package != $GLOBALS['phpDocumentor_DefaultPackageName'])
+ {
+ // child package need root for class trees
+ if ($x->docblock->package != $db->docblock->package)
+ {
+// debug("adding roots $child in $childfile 2");
+ $this->roots[$child][] = $childfile;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Get the parserClass representation of a class from its name and file
+ * @return parserClass
+ * @param string $class classname
+ * @param string $file file classname is located in
+ */
+ function &getClass($class, $file)
+ {
+// debug("getClass called with class $class file $file");
+ return $this->classesbyfile[$file][$class];
+ }
+
+ /**
+ * Used by {@link parserData::getClasses()} to retrieve classes defined in file $path
+ *
+ * retrieves the array entry from {@link $classesbyfile} for $path
+ * @param string $path full path to filename
+ * @return mixed returns false if no classes defined in the file, otherwise returns an array of {@link parserClass}es
+ */
+ function getClassesInPath($path)
+ {
+ if (!isset($this->classesbyfile[$path])) return false;
+ return $this->classesbyfile[$path];
+ }
+
+ /**
+ * called by {@link parserClass::hasMethods()}. Should not be directly called
+ * @access private
+ * @param string $file
+ * @param string $class
+ */
+ function hasMethods($file,$class)
+ {
+ return isset($this->methodsbyfile[$file][$class]);
+ }
+
+ /**
+ * called by {@link parserClass::hasConsts()}. Should not be directly called
+ * @access private
+ * @param string $file
+ * @param string $class
+ */
+ function hasConsts($file,$class)
+ {
+ return isset($this->constsbyfile[$file][$class]);
+ }
+
+ /**
+ * called by {@link parserClass::hasVars()}. Should not be directly called
+ * @access private
+ * @param string $file
+ * @param string $class
+ */
+ function hasVars($file, $class)
+ {
+ return isset($this->varsbyfile[$file][$class]);
+ }
+
+ /**
+ * called by {@link parserClass::hasMethod()}. Should not be directly called
+ * @param string $file
+ * @param string $class
+ * @param string $name method name
+ * @access private
+ */
+ function hasMethod($class, $file, $name)
+ {
+ if (!$this->hasMethods($file, $class)) return false;
+ for($i=0; $i<count($this->methodsbyfile[$file][$class]); $i++)
+ {
+ if ($this->methodsbyfile[$file][$class][$i]->getName() == $name) return true;
+ }
+ return false;
+ }
+
+ /**
+ * called by {@link parserClass::hasVar()}. Should not be directly called
+ * @param string $file
+ * @param string $class
+ * @param string $name var name
+ * @access private
+ */
+ function hasVar($class, $file, $name)
+ {
+ if (!$this->hasVars($file, $class)) return false;
+ for($i=0; $i<count($this->varsbyfile[$file][$class]); $i++)
+ {
+ if ($this->varsbyfile[$file][$class][$i]->getName() == $name) return true;
+ }
+ return false;
+ }
+
+ /**
+ * called by {@link parserClass::hasConst()}. Should not be directly called
+ * @param string $file
+ * @param string $class
+ * @param string $name var name
+ * @access private
+ */
+ function hasConst($class, $file, $name)
+ {
+ if (!$this->hasConsts($file, $class)) return false;
+ for($i=0; $i<count($this->constsbyfile[$file][$class]); $i++)
+ {
+ if ($this->constsbyfile[$file][$class][$i]->getName() == $name) return true;
+ }
+ return false;
+ }
+
+ /**
+ * called by {@link parserClass::getMethods()}. Should not be directly called
+ * @access private
+ * @param string $class
+ * @param string $file
+ */
+ function &getMethods($class, $file)
+ {
+ if (!isset($this->methodsbyfile[$file][$class])) return false;
+ return $this->methodsbyfile[$file][$class];
+ }
+
+ /**
+ * called by {@link parserClass::getVars()}. Should not be directly called
+ * @access private
+ * @param string $class
+ * @param string $file
+ */
+ function &getVars($class, $file)
+ {
+ if (!isset($this->varsbyfile[$file][$class])) return false;
+ return $this->varsbyfile[$file][$class];
+ }
+
+ /**
+ * called by {@link parserClass::getConsts()}. Should not be directly called
+ * @access private
+ * @param string $class
+ * @param string $file
+ */
+ function &getConsts($class, $file)
+ {
+ if (!isset($this->constsbyfile[$file][$class])) return false;
+ return $this->constsbyfile[$file][$class];
+ }
+
+ /**
+ * called by {@link parserClass::getMethod()}. Should not be directly called
+ * @param string $class
+ * @param string $file
+ * @param string $name method name
+ * @access private
+ */
+ function getMethod($class, $file, $name)
+ {
+ if (!$this->hasMethod($class, $file, $name)) return false;
+ for($i=0; $i<count($this->methodsbyfile[$file][$class]); $i++)
+ {
+ if ($this->methodsbyfile[$file][$class][$i]->getName() == $name) return $this->methodsbyfile[$file][$class][$i];
+ }
+ }
+
+ /**
+ * called by {@link parserClass::getVar()}. Should not be directly called
+ * @param string $class
+ * @param string $file
+ * @param string $name var name
+ * @access private
+ */
+ function getVar($class, $file, $name)
+ {
+ if (!$this->hasVar($class, $file, $name)) return false;
+ for($i=0; $i<count($this->varsbyfile[$file][$class]); $i++)
+ {
+ if ($this->varsbyfile[$file][$class][$i]->getName() == $name) return $this->varsbyfile[$file][$class][$i];
+ }
+ }
+
+ /**
+ * called by {@link parserClass::getConst()}. Should not be directly called
+ * @param string $class
+ * @param string $file
+ * @param string $name var name
+ * @access private
+ */
+ function getConst($class, $file, $name)
+ {
+ if (!$this->hasConst($class, $file, $name)) return false;
+ for($i=0; $i<count($this->constsbyfile[$file][$class]); $i++)
+ {
+ if ($this->constsbyfile[$file][$class][$i]->getName() == $name) return $this->constsbyfile[$file][$class][$i];
+ }
+ }
+
+ /**
+ * Search for a class in a package
+ * @return mixed returns false if no class in $package, otherwise returns a {@link parserClass}
+ * @param string $class classname
+ * @param string $package package classname is in
+ */
+ function &getClassByPackage($class,$package)
+ {
+ if (!isset($this->classesbynamefile[$class]))
+ {
+// addWarning(PDERROR_CLASS_NOT_IN_PACKAGE,$class,$package); // removed, too many warnings, not very useful
+ return false;
+ }
+ for($i=0; $i < count($this->classesbynamefile[$class]); $i++)
+ {
+ $cls = $this->classesbyfile[$this->classesbynamefile[$class][$i]][$class];
+ $pkg = $cls->getPackage();
+ if ($pkg == $package)
+ return $cls;
+ }
+// addWarning(PDERROR_CLASS_NOT_IN_PACKAGE,$class,$package);
+ return false;
+ }
+
+ /**
+ * Find the parent class of a class in file $file
+ * uses 3 tests to find the parent classname:
+ * <ol>
+ * <li>only one class with the parent classname</li>
+ * <li>more than one class, but only one in the same file as the child</li>
+ * <li>only one parent class in the same package as the child</li>
+ * </ol>
+ * @return mixed false if no parent class, a string if no parent class found by that name,
+ * and an array(file parentclass is in,parentclassname)
+ */
+ function getParentClass($class,$file)
+ {
+ if (!isset($this->classesbyfile[$file][$class]))
+ {
+ return false;
+ }
+ $element = $this->classesbyfile[$file][$class];
+ if (!($ex = $element->getExtends())) return false;
+ // first check to see if there is one and only one class with the parent class's name
+ if (isset($this->classesbynamefile[$ex]))
+ {
+ if (count($this->classesbynamefile[$ex]) == 1)
+ {
+ if ($this->classesbyfile[$this->classesbynamefile[$ex][0]][$ex]->ignore) return $ex;
+ return array($this->classesbynamefile[$ex][0],$ex);
+ } else
+ {
+ // next check to see if there is a parent class in the same file
+ if (isset($this->classesbyfile[$file][$ex]))
+ {
+ if ($this->classesbyfile[$file][$ex]->ignore) return $ex;
+ return array($file,$ex);
+ }
+ // next check to see if there is only one package used in the file, try to resolve it that way
+ if (isset($this->classpackagebyfile[$file]))
+ {
+ if (count($this->classpackagebyfile[$file]) == 1)
+ {
+ for($i=0;$i<count($this->classesbynamefile[$ex]);$i++)
+ {
+ if ($this->classesbyfile[$this->classesbynamefile[$ex][$i]][$ex]->getPackage() == $this->classpackagebyfile[$file][0])
+ {
+ if ($this->classesbyfile[$this->classesbynamefile[$ex][$i]][$ex]->ignore) return $ex;
+ return array($this->classesbynamefile[$ex][$i],$ex);
+ }
+ }
+ }
+ }
+ // name conflict
+ addWarning(PDERROR_INHERITANCE_CONFLICT, $class, $file, $ex);
+ return $ex;
+ }
+ } else
+ {
+ addWarning(PDERROR_PARENT_NOT_FOUND, $class, $ex);
+ return $ex;
+ }
+ }
+
+ /**
+ * Get a list of all root classes indexed by package. Used to generate
+ * class trees by {@link Converter}
+ * @return array array(package => array(rootclassname, rootclassname,...),...)
+ */
+ function getRoots()
+ {
+ $roots = array();
+ foreach($this->roots as $class => $files)
+ {
+ if (count($files))
+ {
+ foreach($files as $i => $boofou)
+ {
+ $x = $this->getClass($class,$files[$i]);
+ $roots[$x->getPackage()][] = $class;
+ }
+ }
+ }
+ foreach($roots as $package => $root)
+ {
+ usort($roots[$package],"strnatcasecmp");
+ }
+ return $roots;
+ }
+
+ /**
+ * Get all classes confirmed in parsing to be descended class $parclass in file $file
+ * @return mixed either false if no children, or array of format
+ * array(childname => childfile,childname2 => childfile2,...)
+ * @param string $parclass name of parent class
+ * @param string $file file parent class is found in
+ * @see parserClass::getChildClassList()
+ * @uses $definitechild
+ */
+ function getDefiniteChildren($parclass,$file)
+ {
+ if (isset($this->definitechild[$parclass][$file])) return $this->definitechild[$parclass][$file];
+ return false;
+ }
+}
+?>
|