function taxonomy_edge_get_tree_generic in Taxonomy Edge 6
Same name and namespace in other branches
- 8 taxonomy_edge.core.inc \taxonomy_edge_get_tree_generic()
- 7.2 taxonomy_edge.core.inc \taxonomy_edge_get_tree_generic()
- 7 taxonomy_edge.core.inc \taxonomy_edge_get_tree_generic()
Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent.
See also
3 calls to taxonomy_edge_get_tree_generic()
- TaxonomyEdgeTreeTestCase::formatTree in tests/
tree.test - taxonomy_edge_get_tree in ./
taxonomy_edge.module - Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent.
- taxonomy_edge_get_tree_optimized in ./
taxonomy_edge.core.inc - Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent AND use presorting.
File
- ./
taxonomy_edge.core.inc, line 13 - This file contains the core override functions
Code
function taxonomy_edge_get_tree_generic($vid, $parent = 0, $max_depth = NULL) {
$exclude_root = variable_get('taxonomy_edge_exclude_root', TRUE);
$static_cache = variable_get('taxonomy_edge_static_caching', TAXONOMY_EDGE_STATIC_CACHING);
// @todo Optimize this. Currently we cannot use the static cache when using parent,
// because it's expected that the entire vocabulary is present in the static cache.
$static_cache = $static_cache && !$parent;
if ($static_cache) {
static $children = array();
static $parents = array();
static $terms = array();
}
else {
$children = $parents = $terms = array();
}
// We cache trees, so it's not CPU-intensive to call get_tree() on a term
// and its children, too.
if (!isset($children[$vid])) {
$children[$vid] = array();
$parents[$vid] = array();
$terms[$vid] = array();
$result = db_query(db_rewrite_sql("SELECT t.tid, t.*, parent \n FROM {term_data} t\n INNER JOIN {term_hierarchy} h ON t.tid = h.tid\n WHERE t.vid = %d\n AND t.tid IN (SELECT e.tid FROM {term_edge} e WHERE e.vid = %d AND e.parent = %d AND e.distance > 0)\n ORDER BY weight, name\n ", 't', 'tid'), $vid, $vid, $parent);
while ($term = db_fetch_object($result)) {
$children[$vid][$term->parent][] = $term->tid;
$parents[$vid][$term->tid][] = $term->parent;
$terms[$vid][$term->tid] = $term;
}
}
$max_depth = !isset($max_depth) ? count($children[$vid]) : $max_depth;
$tree = array();
// Keeps track of the parents we have to process, the last entry is used
// for the next processing step.
$process_parents = array();
$process_parents[] = $parent;
// Loops over the parent terms and adds its children to the tree array.
// Uses a loop instead of a recursion, because it's more efficient.
while (count($process_parents)) {
$parent = array_pop($process_parents);
// The number of parents determines the current depth.
$depth = count($process_parents);
if ($max_depth > $depth && !empty($children[$vid][$parent])) {
$has_children = FALSE;
$child = current($children[$vid][$parent]);
do {
if (empty($child)) {
break;
}
$term = $terms[$vid][$child];
if (isset($parents[$vid][$term->tid])) {
// Clone the term so that the depth attribute remains correct
// in the event of multiple parents.
$term = clone $term;
}
$term->depth = $depth;
unset($term->parent);
$term->parents = $parents[$vid][$term->tid];
$tree[] = $term;
if (!empty($children[$vid][$term->tid])) {
$has_children = TRUE;
// We have to continue with this parent later.
$process_parents[] = $parent;
// Use the current term as parent for the next iteration.
$process_parents[] = $term->tid;
// Reset pointers for child lists because we step in there more often
// with multi parents.
reset($children[$vid][$term->tid]);
// Move pointer so that we get the correct term the next time.
next($children[$vid][$parent]);
break;
}
} while ($child = next($children[$vid][$parent]));
if (!$has_children) {
// We processed all terms in this hierarchy-level, reset pointer
// so that this function works the next time it gets called.
reset($children[$vid][$parent]);
}
}
}
return $tree;
}