Base class for materialize path based trees Based on implementation of Werner Randelshofer. More...

Inheritance diagram for ilMaterializedPathTree:

Collaboration diagram for ilMaterializedPathTree:

Public Member Functions
	__construct (ilTree $a_tree)
	Constructor. More...

	getTree ()
	Get tree object. More...

	getSubTreeIds ($a_node_id)
	Get subtree ids. More...

	getRelation ($a_node_a, $a_node_b)
	Get relation of two nodes. More...

	getSubTreeQuery ($a_node, $a_types='', $a_force_join_reference=true, $a_fields=array())
	Get subtree query. More...

	getPathIds ($a_endnode, $a_startnode=0)
	Get path ids. More...

	insertNode ($a_node_id, $a_parent_id, $a_pos)
	Insert new node under parent node. More...

	deleteTree ($a_node_id)
	Delete a subtree. More...

	moveToTrash ($a_node_id)
	Move subtree to trash. More...

	moveTree ($a_source_id, $a_target_id, $a_position)
	move source subtree to target node More...

	getSubtreeInfo ($a_endnode_id)
	Get subtree info lft, rgt, path, child, type. More...

	validateParentRelations ()
	Validaate parent relations. More...

Static Public Member Functions
static	createFromParentReleation ()

Protected Member Functions
	getMaximumPossibleDepth ()
	Get maximum possible depth. More...

Static Private Member Functions
static	createMaterializedPath ($parent, $parentPath)

Private Attributes
	$maximum_possible_depth = 100

	$tree = NULL

Detailed Description

Base class for materialize path based trees Based on implementation of Werner Randelshofer.

Author: Stefan Meyer meyer.nosp@m.@lei.nosp@m.fos.c.nosp@m.om

Version: $Id$

Definition at line 16 of file class.ilMaterializedPathTree.php.

Constructor & Destructor Documentation

◆ __construct()

ilMaterializedPathTree::__construct ( ilTree $a_tree )

Constructor.

Parameters

ilTree $tree

Definition at line 25 of file class.ilMaterializedPathTree.php.

         {
                 $this->tree = $a_tree;
         }

Member Function Documentation

◆ createFromParentReleation()

static ilMaterializedPathTree::createFromParentReleation ( )

static

Definition at line 456 of file class.ilMaterializedPathTree.php.

References $ilDB, $r, $row, and $success.

Referenced by ilSCTreeTasksGUI\repairStructure(), and ilSetupGUI\switchTree().

         {
                  global $ilDB;
 
                 $r = $ilDB->queryF('SELECT DISTINCT * FROM tree WHERE parent = %s', array('integer'), array(0));
 
                 while ($row = $ilDB->fetchAssoc($r))
                 {
                         $success = self::createMaterializedPath(0, '');
 
                         if ($success !== true)
                         {
                         }
                 }
         }

Here is the caller graph for this function:

◆ createMaterializedPath()

static ilMaterializedPathTree::createMaterializedPath	(	$parent,
		$parentPath
	)

staticprivate

Definition at line 473 of file class.ilMaterializedPathTree.php.

References $ilDB, $r, and $row.

         {
                 global $ilDB;
                 $q = ' UPDATE tree
                         SET path = CONCAT(COALESCE(' . $ilDB->quote($parentPath, 'text') . ', \'\'), COALESCE(child, \'\'))
                         WHERE parent = %s';
                 $r = $ilDB->manipulateF($q, array('integer'), array($parent));
 
                 $r = $ilDB->queryF('SELECT child FROM tree WHERE parent = %s', array('integer'), array($parent));
 
                 while ($row = $ilDB->fetchAssoc($r))
                 {
                         self::createMaterializedPath($row['child'], $parentPath . $row['child'] . '.');
                 }
 
                 return true;
         }

◆ deleteTree()

ilMaterializedPathTree::deleteTree ( $a_node_id )

Delete a subtree.

Parameters

int $a_node_id

Implements ilTreeImplementation.

Definition at line 273 of file class.ilMaterializedPathTree.php.

References $ilDB, $query, and getTree().

         {
                 global $ilDB;
                 
                 $a_node = $this->getTree()->getNodeData($a_node_id);
                 
                 $query = 'DELETE FROM '.$this->getTree()->getTreeTable().' '.
                                 'WHERE path BETWEEN '.$ilDB->quote($a_node['path'],'text').' '.
                                 'AND '.$ilDB->quote($a_node['path'].'.Z','text').' '.
                                 'AND '.$this->getTree()->getTreePk().' = '.$ilDB->quote($a_node[$this->getTree()->getTreePk()]);
                 $ilDB->manipulate($query);
                 return true;
         }

Here is the call graph for this function:

◆ getMaximumPossibleDepth()

ilMaterializedPathTree::getMaximumPossibleDepth ( )

protected

Get maximum possible depth.

Returns: type

Definition at line 35 of file class.ilMaterializedPathTree.php.

References $maximum_possible_depth.

         {
                 return $this->maximum_possible_depth;
         }

◆ getPathIds()

ilMaterializedPathTree::getPathIds	(	$a_endnode,
		$a_startnode = `0`
	)

Get path ids.

Parameters

int	$a_endnode
int	$a_startnode

Implements ilTreeImplementation.

Definition at line 169 of file class.ilMaterializedPathTree.php.

References $ilDB, $path, $query, $res, $row, and getTree().

         {
                 global $ilDB;
                 
                 $ilDB->setLimit(1);
                 $query = 'SELECT path FROM ' . $this->getTree()->getTreeTable() .' '.
                         'WHERE child = '. $ilDB->quote($a_endnode,'integer').' ';
                 $res = $ilDB->query($query);
 
                 $path = null;
                 while ($row = $ilDB->fetchAssoc($res))
                 {
                         $path = $row['path'];
                 }
 
                 $pathIds = explode('.', $path);
 
                 if ($a_startnode != 0)
                 {
                         while (count($pathIds) > 0 && $pathIds[0] != $a_startnode)
                         {
                                 array_shift($pathIds);
                         }
                 }
                 return $pathIds;
         }

Here is the call graph for this function:

◆ getRelation()

ilMaterializedPathTree::getRelation	(	$a_node_a,
		$a_node_b
	)

Get relation of two nodes.

Parameters

type	$a_node_a
type	$a_node_b

Implements ilTreeImplementation.

Definition at line 82 of file class.ilMaterializedPathTree.php.

References $GLOBALS, ilTree\RELATION_CHILD, ilTree\RELATION_EQUALS, ilTree\RELATION_NONE, ilTree\RELATION_PARENT, and ilTree\RELATION_SIBLING.

         {
                 if($a_node_a['child'] == $a_node_b['child'])
                 {
                         $GLOBALS['ilLog']->write(__METHOD__.': EQUALS');
                         return ilTree::RELATION_EQUALS;
                 }
                 if(stripos($a_node_a['path'], $a_node_b['path']. '.') === 0)
                 {
                         $GLOBALS['ilLog']->write(__METHOD__.': CHILD');
                         return ilTree::RELATION_CHILD;
                 }
                 if(stripos($a_node_b['path'], $a_node_a['path'] . '.') === 0)
                 {
                         $GLOBALS['ilLog']->write(__METHOD__.': PARENT');
                         return ilTree::RELATION_PARENT;
                 }
                 $path_a = substr($a_node_a['path'],0,strrpos($a_node_a['path'],'.'));
                 $path_b = substr($a_node_b['path'],0,strrpos($a_node_b['path'],'.'));
                 $GLOBALS['ilLog']->write(__METHOD__.': Comparing '.$path_a .' '. 'with '.$path_b);
 
                 if($a_node_a['path'] and (strcmp($path_a,$path_b) === 0))
                 {
                         $GLOBALS['ilLog']->write(__METHOD__.': SIBLING');
                         return ilTree::RELATION_SIBLING;
                 }
 
                 $GLOBALS['ilLog']->write(__METHOD__.': NONE');
                 return ilTree::RELATION_NONE;
         }

◆ getSubTreeIds()

ilMaterializedPathTree::getSubTreeIds ( $a_node_id )

Get subtree ids.

Parameters

type $a_node_id

Implements ilTreeImplementation.

Definition at line 53 of file class.ilMaterializedPathTree.php.

References $ilDB, $query, $res, $row, and getTree().

         {
                 global $ilDB;
                 
                 $node = $this->getTree()->getNodeTreeData($a_node_id);
                 $query = 'SELECT child FROM '.$this->getTree()->getTreeTable().' '.
                                 'WHERE path BETWEEN '.
                                 $ilDB->quote($node['path'], 'text').' AND '.
                                 $ilDB->quote($node['path'].'.Z', 'text').' '.
                                 'AND child != %s '.
                                 'AND '.$this->getTree()->getTreePk().' = %s';
                 
                 $res = $ilDB->queryF(
                                 $query, 
                                 array('integer', 'integer'),
                                 array($a_node_id, $this->getTree()->getTreeId())
                 );
                 while($row = $ilDB->fetchAssoc($res))
                 {
                         $childs[] = $row['child'];
                 }
                 return $childs ? $childs : array();
         }

Here is the call graph for this function:

◆ getSubtreeInfo()

ilMaterializedPathTree::getSubtreeInfo ( $a_endnode_id )

Get subtree info lft, rgt, path, child, type.

Returns: array

Implements ilTreeImplementation.

Definition at line 491 of file class.ilMaterializedPathTree.php.

References $ilDB, $query, $res, $row, DB_FETCHMODE_OBJECT, and getTree().

         {
                 global $ilDB;
                 
                 // This is an optimization without the temporary tables become too big for our system.
                 // The idea is to use a subquery to join and filter the trees, and only the result
                 // is joined to obj_reference and obj_data.
                 
                  $query = "SELECT t2.child child, type, t2.path path " .
                                 "FROM " . $this->getTree()->getTreeTable() . " t1 " .
                                 "JOIN " . $this->getTree()->getTreeTable() . " t2 ON (t2.path BETWEEN t1.path AND CONCAT(t1.path, '.Z')) " .
                                 "JOIN " . $this->getTree()->getTableReference() . " obr ON t2.child = obr.ref_id " .
                                 "JOIN " . $this->getTree()->getObjectDataTable() . " obd ON obr.obj_id = obd.obj_id " .
                                 "WHERE t1.child = " . $ilDB->quote($a_endnode_id, 'integer') . " " .
                                 "AND t1." . $this->getTree()->getTreePk() . " = " . $ilDB->quote($this->getTree()->getTreeId(), 'integer') . " " .
                                 "AND t2." . $this->getTree()->getTreePk() . " = " . $ilDB->quote($this->getTree()->getTreeId(), 'integer') . " " .
                                 "ORDER BY t2.path";
 
                 
                 $res = $ilDB->query($query);
                 $nodes = array();
                 while ($row = $res->fetchRow(DB_FETCHMODE_OBJECT))
                 {
                         #$nodes[$row->child]['lft'] = $row->lft;
                         #$nodes[$row->child]['rgt'] = $row->rgt;
                         $nodes[$row->child]['child'] = $row->child;
                         $nodes[$row->child]['type'] = $row->type;
                         $nodes[$row->child]['path'] = $row->path;
                 }
                 
                 $depth_first_compare = function($a, $b)
                 {
                         $a_exploded = explode('.', $a['path']);
                         #$GLOBALS['ilLog']->write(__METHOD__.': '.print_r($a_exploded,TRUE));
                         $b_exploded = explode('.', $b['path']);
                         
                         $a_padded = '';
                         foreach($a_exploded as $num)
                         {
                                 $a_padded .= (str_pad((string) $num, 14,'0', STR_PAD_LEFT));
                         }
                         $b_padded = '';
                         foreach($b_exploded as $num)
                         {
                                 $b_padded .= (str_pad((string) $num, 14, '0', STR_PAD_LEFT));
                         }
                         #$GLOBALS['ilLog']->write(__METHOD__.': '.$a_padded);
                         #$GLOBALS['ilLog']->write(__METHOD__.': '.$a_padded);
                         return strcasecmp($a_padded, $b_padded);
                 };
                 
                 #$GLOBALS['ilLog']->write(__METHOD__.': '.print_r($nodes,TRUE));
                 
                 uasort($nodes,$depth_first_compare);
 
                 #$GLOBALS['ilLog']->write(__METHOD__.': '.print_r($nodes,TRUE));
 
                 return (array) $nodes;
         }

Here is the call graph for this function:

◆ getSubTreeQuery()

ilMaterializedPathTree::getSubTreeQuery	(	$a_node,
		$a_types = `''`,
		$a_force_join_reference = `true`,
		$a_fields = `array()`
	)

Get subtree query.

Parameters

type	$a_node
type	$a_types

Implements ilTreeImplementation.

Definition at line 119 of file class.ilMaterializedPathTree.php.

References $ilDB, $query, and getTree().

         {
                 global $ilDB;
                 
                 $type_str = '';
                 if(is_array($a_types))
                 {
                         if($a_types)
                         {
                                 $type_str = "AND ".$ilDB->in($this->getTree()->getObjectDataTable().".type", $a_types, false, "text");
                         }
                 }
                 else if(strlen($a_types))
                 {
                         $type_str = "AND ".$this->getTree()->getObjectDataTable().".type = ".$ilDB->quote($a_types, "text");
                 }
 
                 $join = '';
                 if($type_str or $a_force_join_reference)
                 {
                         $join = $this->getTree()->buildJoin();
                 }
                 
                 $fields = '* ';
                 if(count($a_fields))
                 {
                         $fields = implode(',',$a_fields);
                 }
 
                 // @todo order by
                 $query = 'SELECT '.
                                 $fields.' '.
                                 'FROM '.$this->getTree()->getTreeTable().' '.
                                 $join.' '.
                                 'WHERE '.$this->getTree()->getTreeTable().'.path '.
                                 'BETWEEN '.
                                 $ilDB->quote($a_node['path'],'text').' AND '.
                                 $ilDB->quote($a_node['path'].'.Z','text').' '.
                                 'AND '.$this->getTree()->getTreeTable().'.'.$this->getTree()->getTreePk().' = '.$ilDB->quote($this->getTree()->getTreeId(),'integer').' '.
                                 $type_str.' '.
                                 'ORDER BY '.$this->getTree()->getTreeTable().'.path';
                 
                 return $query;
         }

Here is the call graph for this function:

◆ getTree()

ilMaterializedPathTree::getTree ( )

Get tree object.

Returns: ilTree $tree

Definition at line 44 of file class.ilMaterializedPathTree.php.

References $tree.

Referenced by deleteTree(), getPathIds(), getSubTreeIds(), getSubtreeInfo(), getSubTreeQuery(), insertNode(), moveToTrash(), moveTree(), and validateParentRelations().

         {
                 return $this->tree;
         }

Here is the caller graph for this function:

◆ insertNode()

ilMaterializedPathTree::insertNode	(	$a_node_id,
		$a_parent_id,
		$a_pos
	)

Insert new node under parent node.

Parameters

type	$a_node_id
type	$a_parent_id
type	$a_pos

Implements ilTreeImplementation.

Definition at line 202 of file class.ilMaterializedPathTree.php.

References $GLOBALS, $ilDB, $r, $res, getTree(), and ilDB\LOCK_WRITE.

         {
                 global $ilDB;
                  
                 // LOCKED ###########################################################
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->lockTables(
                                         array(
                                                 0 => array('name' => 'tree', 'type' => ilDB::LOCK_WRITE)));
                 }
 
                 // get path and depth of parent
                 $ilDB->setLimit(1);
                 
                 $res = $ilDB->queryF(
                         'SELECT parent, depth, path FROM ' . $this->getTree()->getTreeTable() . ' ' .
                         'WHERE child = %s '. ' '.
                         'AND ' . $this->getTree()->getTreePk() . ' = %s', array('integer', 'integer'), 
                         array($a_parent_id, $this->getTree()->getTreeId()));
 
 
                 $r = $ilDB->fetchObject($res);
 
                 if ($r->parent == NULL)
                 {
                         if ($this->getTree()->__isMainTree())
                         {
                                 $ilDB->unlockTables();
                         }
                         $GLOBALS['ilLog']->logStack();
                         throw new ilInvalidTreeStructureException('Parent node not found in tree');
                 }
 
                 if ($r->depth >= $this->getMaximumPossibleDepth())
                 {
                         // LOCKED ###########################################################
                         if ($this->getTree()->__isMainTree())
                         {
                                 $ilDB->unlockTables();
                         }
                         $GLOBALS['ilLog']->logStack();
                         throw new ilInvalidTreeStructureException('Maximum tree depth exceeded');
                 }
 
                 $parentPath = $r->path;
                 $depth = $r->depth + 1;
                 $lft = 0;
                 $rgt = 0;
 
 
                 $ilDB->insert($this->getTree()->getTreeTable(), array($this->getTree()->getTreePk() => array('integer', $this->getTree()->getTreeId()),
                         'child' => array('integer', $a_node_id),
                         'parent' => array('integer', $a_parent_id),
                         'lft' => array('integer', $lft),
                         'rgt' => array('integer', $rgt),
                         'depth' => array('integer', $depth),
                         'path' => array('text', $parentPath . "." . $a_node_id)));
                 
                 
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->unlockTables();
                 }
         }

Here is the call graph for this function:

◆ moveToTrash()

ilMaterializedPathTree::moveToTrash ( $a_node_id )

Move subtree to trash.

Parameters

type $a_node_id

Implements ilTreeImplementation.

Definition at line 291 of file class.ilMaterializedPathTree.php.

References $ilDB, getTree(), and ilDB\LOCK_WRITE.

         {
                 global $ilDB;
  
                 // LOCKED ###########################################################
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->lockTables(
                                         array(
                                                 0 => array('name' => 'tree', 'type' => ilDB::LOCK_WRITE)));
                 }
                 try 
                 {
                         $node = $this->getTree()->getNodeTreeData($a_node_id);
                 }
                 catch(Exception $e) 
                 {
                         if ($this->getTree()->__isMainTree())
                         {
                                 $ilDB->unlockTables();
                         }
                         throw $e;
                 }
 
 
                 // Set the nodes deleted (negative tree id)
                 $ilDB->manipulateF('
                         UPDATE ' . $this->getTree()->getTreeTable().' '.
                         'SET tree = %s' .' '.
                         'WHERE ' . $this->getTree()->getTreePk() . ' = %s ' .
                         'AND path BETWEEN %s AND %s', 
                 array('integer', 'integer', 'text', 'text'),
                 array(-$a_node_id, $this->getTree()->getTreeId(), $node['path'], $node['path'] . '.Z'));
 
                 
                 // LOCKED ###########################################################
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->unlockTables();
                 }
                 return true;
         }

Here is the call graph for this function:

◆ moveTree()

ilMaterializedPathTree::moveTree	(	$a_source_id,
		$a_target_id,
		$a_position
	)

move source subtree to target node

Parameters

type	$a_source_id
type	$a_target_id
type	$a_position

Implements ilTreeImplementation.

Definition at line 340 of file class.ilMaterializedPathTree.php.

References $GLOBALS, $ilDB, $query, $res, $row, getTree(), and ilDB\LOCK_WRITE.

         {
                 global $ilDB;
                 
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->lockTables(
                                         array(
                                                 0 => array('name' => 'tree', 'type' => ilDB::LOCK_WRITE)));
                 }
 
                 // Receive node infos for source and target
                 $ilDB->setLimit(2);
                 $res = $ilDB->query(
                         'SELECT depth, child, parent, path FROM ' . $this->getTree()->getTreeTable() . ' '.
                         'WHERE ' . $ilDB->in('child', array($a_source_id, $a_target_id), false, 'integer') . ' '.
                         'AND tree = ' . $ilDB->quote($this->getTree()->getTreeId(), 'integer')
                 );
 
                 // Check in tree
                 if ($ilDB->numRows($res) != 2)
                 {
                         if ($this->getTree()->__isMainTree())
                         {
                                 $ilDB->unlockTables();
                         }
                         $GLOBALS['ilLog']->logStack();
                         $GLOBALS['ilLog']->write(__METHOD__.': Objects not found in tree');
                         throw new InvalidArgumentException('Error moving subtree');
                 }
 
                 while ($row = $ilDB->fetchObject($res))
                 {
                         if ($row->child == $a_source_id)
                         {
                                 $source_path = $row->path;
                                 $source_depth = $row->depth;
                                 $source_parent = $row->parent;
                         }
                         else
                         {
                                 $target_path = $row->path;
                                 $target_depth = $row->depth;
                         }
                 }
 
                 if ($target_depth >= $source_depth)
                 {
                         // We move nodes deeper into the tree. Therefore we need to
                         // check whether we might exceed the maximal path length.
                         // We use FOR UPDATE here, because we don't want anyone to
                         // insert new nodes while we move the subtree.
 
                         $res = $ilDB->queryF(
                     'SELECT  MAX(depth) max_depth '.
                     'FROM    ' . $this->getTree()->getTreeTable() . ' '.
                     'WHERE   path BETWEEN %s AND %s'.' '.
                     'AND     tree = %s ', 
                                 array('text', 'text', 'integer'), array($source_path, $source_path . '.Z', $this->getTree()->getTreeId()));
 
                         $row = $ilDB->fetchObject($res);
 
                         if ($row->max_depth - $source_depth + $target_depth + 1 > $this->getMaximumPossibleDepth())
                         {
                                 if ($this->getTree()->__isMainTree())
                                 {
                                         $ilDB->unlockTables();
                                 }
                                 $GLOBALS['ilLog']->logStack();
                                 $GLOBALS['ilLog']->write(__METHOD__.': Objects not found in tree');
                                 throw new ilInvalidTreeStructureException('Maximum tree depth exceeded');
                         }
                 }
                 // Check target not child of source
                 if (substr($target_path . '.', 0, strlen($source_path) . '.') == $source_path . '.')
                 {
                         if ($this->getTree()->__isMainTree())
                         {
                                 $ilDB->unlockTables();
                         }
                         $GLOBALS['ilLog']->logStack();
                         $GLOBALS['ilLog']->write(__METHOD__.': Target is child of source');
                         throw new ilInvalidArgumentException('Error moving subtree: target is child of source');
                 }
                 $depth_diff = $target_depth - $source_depth + 1;
 
                 // move subtree:
                 $query = '
                 UPDATE ' . $this->getTree()->getTreeTable() . '
                 SET parent = CASE WHEN parent = ' . $ilDB->quote($source_parent, 'integer') . '
                              THEN ' . $ilDB->quote($a_target_id, 'integer') . '
                              ELSE parent END,
 
                     path = ' . $ilDB->concat(array(
                                         array($ilDB->quote($target_path, 'text'), 'text'),
                                         array($ilDB->substr('path', strrpos('.' . $source_path, '.')), 'text'))) . ' ,
 
                     depth = depth + ' . $ilDB->quote($depth_diff, 'integer') . '
 
                 WHERE path  BETWEEN ' . $ilDB->quote($source_path, 'text') . '
                             AND ' . $ilDB->quote($source_path . '.Z', 'text') . '
 
                 AND tree = ' . $ilDB->quote($this->getTree()->getTreeId(), 'integer');
                 
                 $GLOBALS['ilLog']->write(__METHOD__.': query is ' . $query);
 
 
                 $ilDB->manipulate($query);
                 if ($this->getTree()->__isMainTree())
                 {
                         $ilDB->unlockTables();
                 }
                 return true;
         }

Here is the call graph for this function:

◆ validateParentRelations()

ilMaterializedPathTree::validateParentRelations ( )

Validaate parent relations.

Returns: int[] array of failure nodes

Implements ilTreeImplementation.

Definition at line 555 of file class.ilMaterializedPathTree.php.

References $ilDB, $query, $res, $row, DB_FETCHMODE_ASSOC, ilLoggerFactory\getLogger(), and getTree().

         {
                 global $ilDB;
                 
                 $query = 'select child from '.$this->getTree()->getTreeTable().' child where not exists '.
                                 '( '.
                                         'select child from '.$this->getTree()->getTreeTable().' parent where child.parent = parent.child and '.
                                         '(child.path BETWEEN parent.path AND CONCAT(parent.path,'.$ilDB->quote('Z','text').') )'.                               ')'.
                                 'and '.$this->getTree()->getTreePk().' = '.$this->getTree()->getTreeId().' and child <> 1';
                 $res = $ilDB->query($query);
                 
                 ilLoggerFactory::getLogger('tree')->debug($query);
                 
                 $failures = array();
                 while($row = $res->fetchRow(DB_FETCHMODE_ASSOC))
                 {
                         $failures[] = $row[$this->getTree()->getTreePk()];
                 }
                 return $failures;
         }

Here is the call graph for this function:

Field Documentation

◆ $maximum_possible_depth

ilMaterializedPathTree::$maximum_possible_depth = 100

private

Definition at line 18 of file class.ilMaterializedPathTree.php.

Referenced by getMaximumPossibleDepth().

◆ $tree

ilMaterializedPathTree::$tree = NULL

private

Definition at line 19 of file class.ilMaterializedPathTree.php.

Referenced by getTree().

The documentation for this class was generated from the following file:

Services/Tree/classes/class.ilMaterializedPathTree.php

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ createFromParentReleation()

◆ createMaterializedPath()

◆ deleteTree()

◆ getMaximumPossibleDepth()

◆ getPathIds()

◆ getRelation()

◆ getSubTreeIds()

◆ getSubtreeInfo()

◆ getSubTreeQuery()

◆ getTree()

◆ insertNode()

◆ moveToTrash()

◆ moveTree()

◆ validateParentRelations()

Field Documentation

◆ $maximum_possible_depth

◆ $tree