Tree structure data access class instance implemented by PHP, tree instance_PHP tutorial

/**
 * Tanphp framework
 *
 *
 * @category   Tanphp
 * @package    Data_structure
 * @version    $Id: Tree.php 25024 2012-11-26 22:22:22 tanbo $
 */

/**
* Tree structure data access class
*
* Used for fast access to tree structure data
*
* @param array $arr The parameter must be a standard two-dimensional array, including the index field (id) and the field representing the tree structure (path), as shown in example
*
* @example <br> * $arr = array( <br> * array( 'id' => 1, 'name' => 'php', 'path' => '1' ), <br> * array( 'id' => 3, 'name' => 'php1', 'path' => '1-3' ), <br> * array( 'id' => 2, 'name' => 'mysql', 'path' => '2' ), <br> * array( 'id' => 6, 'name' => 'mysql1', 'path' => '2-6' ), <br> * array( 'id' => 7, 'name' => 'mysql2', 'path' => '2-7' ), <br> * array( 'id' => 5, 'name' => 'php11', 'path' => '1-3-5' ), <br> * array( 'id' => 4, 'name' => 'php2', 'path' => '1-4' ), <br> * ); <br> * $cate = new Tree($arr); <br> * <br> * $data = $cate->getChild(2); <br> * <br> * print_r($data->toArray()); <br> *
*
​*/
class Tree
{
Public $_info; //Node information
Public $_child = array(); //Child node
private $_parent; //Parent node
private $_data; //Temporary data for the current operation
Private static $_indexs = array(); //Indices of all nodes
Private static $_index_key = 'id'; //Index key
Private static $_tree_key = 'path'; //Tree structure expression key
Private static $_tree_delimiter = '-'; //Attribute structure expression delimiter
     
/**
* Constructor
* *
* @param array $arr
* @param boole $force_sort If true, $arr will be forced to be sorted
* @return void
​​*/
Public function __construct(array $arr = array(), $force_sort=true)
{
If ($force_sort === true) {
                  $arr=$this->_array_sort($arr, self::$_tree_key);
          }
If (!emptyempty($arr)) {
                  $this->_init($arr);
          }
}
     
/**
* Initial storage of tree data
* *
* @param array $arr
* @return void
​​*/
Private function _init(array $arr)
{
foreach ($arr as $item) {
                                                                                                                                                                                                                                                                                                                                                                                             $count_paths = count($paths);
$parent_id = isset($paths[$count_paths-2]) ? $paths[$count_paths-2] : NULL;
                                                                          if ( $count_paths>1                                                                                                                                                                                                             && array_key_exists($parent_id, self::$_indexs)                                                                  ​                                                                                                                                                                                                                                          && self::$_indexs[$parent_id] instanceof Tree                          ) {
                                                            self::$_indexs[$parent_id]->addChild($item);
                } elseif ($count_paths == 1) {
$this->addChild($item);
                } else {
                      throw new Exception("path data error".var_export($item, true));
               }
          }
                                   
​​​​ //print_r(self::$_indexs);
}
     
/**
* Add child node
* *
* @param array $item
* @return void
​​*/
Public function addChild(array $item, $parent = NULL)
{
$child = new Tree();
$child->_info = $item;
$child->_parent = $parent == NULL ? $this : $parent;
$child->_parent->_child[] = $child;
                                   
            $this->_addIndex($item, $child->_getSelf());
}
     
/**
* Add node to index
* *
* @param array $item
* @param mix $value
* @return void
​​*/
Private function _addIndex(array $item, $value)
{
If (array_key_exists(self::$_index_key, $item) && is_int($item[self::$_index_key])) {
                  self::$_indexs[$item[self::$_index_key]] = $value;
         } else {
                  throw new Exception("The id field does not exist or is not a string");
          }
}
     
/**
* Get a reference to yourself
* *
* @return Tree object quote
​​*/
Private function _getSelf()
{
          return $this;
}
     
/**
* * Get the child nodes of the node with the specified id
* *
* @param int $id
* @return Tree object
​​*/
Public function getChild($id)
{
        $data       = self::$_indexs[$id]->_child;
        $this->_data = $data;
        return $this;
    }
    
    /**
* Get the parent node of the node with the specified id
* *
* @param int $id
* @return Tree object
​​*/
    public function getParent($id)
    {
        $data = self::$_indexs[$id]->_parent;
        $this->_data = $data;
        return $this;
    }
    
    /**
* Get the sibling nodes of the node with the specified id
* *
* @param int $id
* @return Tree object
​​*/
    public function getBrother($id)
    {
        $data = self::$_indexs[$id]->_parent->_child;
        $this->_data = $data;
        return $this;
    }
    
    /**
* Convert Tree object into array
* *
* @param object $object
* @return array
​​*/
     public function toArray($obj = NULL)
     {
        $obj  = ($obj === NULL) ? $this->_data : $obj;
        $arr  = array();
        $_arr = is_object($obj) ? $this->_getBaseInfo($obj) : $obj;
        
        if (is_array($_arr)) {
            foreach ($_arr as $key => $val){
                
                $val = (is_array($val) || is_object($val)) ? $this->toArray($val) : $val;
                $arr[$key] = $val;
            }
        } else {
            throw new Exception("_arr不是数组");
        }
     
        return $arr;
    }
    
    /**
* * Filter fields such as _parent to avoid infinite loops
* *
* @param object $obj
* @return void
​​*/
    private function _getBaseInfo($obj)
    {
        $vars = get_object_vars($obj);
        $baseInfo['_info']  =  $vars['_info'];
        $baseInfo['_child'] =  $vars['_child'];
        return $baseInfo;
    }
    
    /**
* * Two-dimensional array sorting
* *
* Arrange the two-dimensional array in ascending or descending order according to the specified key name
* *
* @param array $arr two-dimensional array
* @param string $keys
* @param string $type must be asc or desc
* @throws throws an exception when the parameter is illegal
* @return Returns the sorted array
​​*/
    private function _array_sort(array $arr, $keys, $type = 'asc') {
If (!is_string($keys)) {
                  throw new Exception("Illegal parameter keys: The type of parameter keys must be string");
          }
     
          $keysvalue = $new_array = array();
foreach ($arr as $k=>$v) {
If (!is_array($v) || !isset($v[$keys])) {
                      throw new Exception("The parameter arr is not a two-dimensional array or the key '{$keys}' does not exist in the arr sub-element");
               }
               $keysvalue[$k] = $v[$keys];
          }
     
          switch ($type) {
case 'asc':
asort($keysvalue);
break;
case 'desc':
                 arsort($keysvalue);
break;
                  default:
                         throw new Exception("Illegal parameter type: the value of parameter type must be 'asc' or 'desc'");
          }
     
          reset($keysvalue);
foreach ($keysvalue as $k=>$v) {
                $new_array[$k] = $arr[$k];
          }
          return $new_array;
}
}
?>