net.php.pear/Tree/Common.php

<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.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.               |
// +----------------------------------------------------------------------+
// | Authors: Wolfram Kriesing <wolfram@kriesing.de>                      |
// +----------------------------------------------------------------------+
//
//  Id: Common.php,v 1.17 2003/01/28 19:18:37 cain Exp 
//  $Id: Common.php,v 1.17 2003/01/28 19:18:37 cain Exp $

require_once('Tree/OptionsDB.php');

define("TREE_ERROR",                    -1);
define("TREE_ERROR_INVALID_PARENT",     -2);

/**
*   common tree class, implements common functionality
*
*   this class extends Tree_OptionsDB so every class that extends this oe can
*   connect to a db and set options
*
*   @access     public
*   @author     Wolfram Kriesing <wolfram@kriesing.de>
*   @version    2001/06/27
*   @package    Tree
*/
class Tree_Common extends Tree_OptionsDB
{

    /**
    *   put proper value-keys are given in each class, depending on the implementation
    *   only some options are needed or allowed, see the classes which extend this one
    *
    *   @access public
    *   @var    array   saves the options passed to the constructor
    */
    var $options =  array();


    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getChildId( $id )
    {
        $child = $this->getChild( $id );
        return $child['id'];
    }

    /**
    *   get the ids of the children of the given element
    *
    *   @version    2002/02/06
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id             ID of the element that the children shall be retreived for
    *   @return     mixed   an array of all the ids of the children of the element with id=$id,
    *                       or false if there are no children
    */
    function getChildrenIds( $id )
    {
        if( !($children = $this->getChildren( $id )) )  // returns false if no children exist
            return array();                         // return an empty array, if you want to know if there are children, use hasChildren

        if( $children && sizeof($children) )
        {
            foreach( $children as $aChild )
                $childrenIds[] = $aChild['id'];
        }

        return $childrenIds;
    }

    /**
    *   gets all the children and grand children etc.
    *
    *   @version    2002/09/30
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id     ID of the element that the children shall be retreived for
    *   @return     mixed   an array of all the children of the element with id=$id,
    *                       or false if there are no children
    */
    function getAllChildren( $id )
    {
        $retChildren = false;
        if( $children = $this->hasChildren( $id ) )
        {                  
            $retChildren = $this->_getAllChildren( $id );
        }
        return $retChildren;
    }

    /**
    *   this method gets all the children recursively
    *
    *   @see    getAllChildren()
    *   @version    2002/09/30
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id     ID of the element that the children shall be retreived for
    *   @return     mixed   an array of all the ids of the children of the element with id=$id,
    *                       or false if there are no children
    */
    function &_getAllChildren( $id )
    {
        $retChildren = array();
        if( $children = $this->getChildren( $id ) )
        {
            foreach( $children as $key=>$aChild )
            {
                $retChildren[] = &$children[$key];
                $retChildren = array_merge($retChildren,$this->_getAllChildren( $aChild['id'] ));
            }
        }
        return $retChildren;
    }

    /**
    *   gets all the children-ids and grand children-ids
    *
    *   @version    2002/09/30
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id     ID of the element that the children shall be retreived for
    *   @return     mixed   an array of all the ids of the children of the element with id=$id,
    *                       or false if there are no children
    */
    function getAllChildrenIds( $id )
    {                      
        $childrenIds = array();
        if( $allChildren = $this->getAllChildren($id) )
        {
            $childrenIds = array();
            foreach( $allChildren as $aNode )
                $childrenIds[] = $aNode['id'];
        }
        return $childrenIds;
    }
    /**
    *   get the id of the parent for the given element
    *
    *   @version    2002/01/18
    *   @access     public
    *   @param      integer $id the id of the element for which the parentId shall be retreived
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getParentId( $id )
    {
        $parent = $this->getParent( $id );
        return $parent['id'];
    }

    /**
    *   this gets all the preceeding nodes, the parent and it's parent and so on
    *
    *   @version    2002/08/19
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id the id of the element for which the parentId shall be retreived
    *   @return     array   of the parent nodes including the node with id $id
    */
    function getParents( $id )
    {
        $path = $this->getPath($id);
        $parents = array();
        if( sizeof($path) )
            foreach( $path as $aNode )
                $parents[] = $aNode;
        return $parents;
    }

    /**
    *   get the ids of the parents and all it's parents and so on
    *   it simply returns the ids of the elements returned by getParents()

    *   @see    getParents()
    *   @version    2002/08/19
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      integer $id the id of the element for which the parentId shall be retreived
    *   @return     array   of the ids
    */
    function getParentsIds( $id )
    {
        $parents = $this->getParents($id);
        $parentsIds = array();
        if( sizeof($parents) )
            foreach( $parents as $aNode )
                $parentsIds[] = $aNode['id'];
        return $parentsIds;
    }

    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getNextId( $id )
    {
        $next = $this->getNext( $id );
        return $next['id'];
    }

    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getPreviousId( $id )
    {
        $previous = $this->getPrevious( $id );
        return $previous['id'];
    }

    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getLeftId( $id )
    {
        $left = $this->getLeft( $id );
        return $left['id'];
    }

    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getRightId( $id )
    {
        $right = $this->getRight( $id );
        return $right['id'];
    }

    /**
    *
    *
    *   @version    2002/01/18
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getFirstRootId()
    {
        $firstRoot = $this->getFirstRoot();
        return $firstRoot['id'];
    }

    /**
    *
    *
    *   @version    2002/04/16
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    */
    function getRootId()
    {
        $firstRoot = $this->getRoot();
        return $firstRoot['id'];
    }

    /**
    *   returns the path as a string
    *
    *   @access     public
    *   @version    2002/03/28
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      mixed   $id     the id of the node to get the path for
    *   @return     array   this array contains all elements from the root to the element given by the id
    *
    */
    function getPathAsString( $id , $seperator='/' )
    {
        $path = $this->getPath($id);
        foreach( $path as $aNode )
            $pathArray[] = $aNode['name'];

        $pathString = '';
        if( sizeof($pathArray) )
            $pathString = implode($seperator,$pathArray);
        return $pathString;
    } // end of function


    //
    //  abstract methods, those should be overwritten by the implementing class
    //


    /**
    *   gets the path to the element given by its id
    *
    *   @abstract
    *   @version    2001/10/10
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      mixed   $id     the id of the node to get the path for
    *   @return     array   this array contains all elements from the root to the element given by the id
    *
    */
    function getPath( $id )
    {
        return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
    } // end of function

    /**
    *   get the level, which is how far below the root the element with the given id is
    *
    *   @abstract
    *   @version    2001/11/25
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      mixed   $id     the id of the node to get the level for
    *
    */
    function getLevel( $id )
    {
        return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
    } // end of function

    /**
    *   returns if $childId is a child of $id
    *
    *   @abstract
    *   @version    2002/04/29
    *   @access     public
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param      int     id of the element
    *   @param      int     id of the element to check if it is a child
    *   @param      boolean if this is true the entire tree below is checked
    *   @return     boolean true if it is a child
    */
    function isChildOf( $id , $childId , $checkAll=true )
    {
        return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
    } // end of function


    //
    //  PRIVATE METHODS
    //


    /**
    *   prepare multiple results
    *
    *   @see        _prepareResult()
    *   @access     private
    *   @version    2002/03/03
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param
    *   @return
    */
    function _prepareResults( $results )
    {
        $newResults = array();
        foreach( $results as $key=>$aResult )
            $newResults[$key] = $this->_prepareResult($aResult);
        return $newResults;
    }

    /**
    *   map back the index names to get what is expected
    *
    *   @access     private
    *   @version    2002/03/03
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param
    *   @return
    */
    function _prepareResult( $result )
    {
        $map = $this->getOption('columnNameMaps');

        if( $map )
        foreach( $map as $key=>$columnName )
        {
            $result[$key] = $result[$columnName];
            unset($result[$columnName]);
        }
        return $result;
    }

    /**
    *   this method retreives the real column name, as used in the DB
    *   since the internal names are fixed, to be portable between different
    *   DB-column namings, we map the internal name to the real column name here
    *
    *   @access     private
    *   @version    2002/03/02
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param
    *   @return
    */
    function _getColName( $internalName )
    {
        if( $map = $this->getOption( 'columnNameMaps' ) )
        {
            if( isset($map[$internalName]) )
                return $map[$internalName];
        }
        return $internalName;
    }

    /**
    *
    *
    *   @access     private
    *   @version    2002/03/02
    *   @author     Wolfram Kriesing <wolfram@kriesing.de>
    *   @param
    *   @return
    */
    function _throwError( $msg , $line , $mode=null )
    {
        if( $mode===null && $this->debug>0 )
            $mode = PEAR_ERROR_PRINT;
        return new Tree_Error( $msg , $line , __FILE__ , $mode , $this->dbh->last_query );
    }

}
?>
1	joko	1.1	<?php
2			//
3			// +----------------------------------------------------------------------+
4			// \| PHP Version 4 \|
5			// +----------------------------------------------------------------------+
6			// \| Copyright (c) 1997-2003 The PHP Group \|
7			// +----------------------------------------------------------------------+
8			// \| This source file is subject to version 2.02 of the PHP license, \|
9			// \| that is bundled with this package in the file LICENSE, and is \|
10			// \| available at through the world-wide-web at \|
11			// \| http://www.php.net/license/2_02.txt. \|
12			// \| If you did not receive a copy of the PHP license and are unable to \|
13			// \| obtain it through the world-wide-web, please send a note to \|
14			// \| license@php.net so we can mail you a copy immediately. \|
15			// +----------------------------------------------------------------------+
16			// \| Authors: Wolfram Kriesing <wolfram@kriesing.de> \|
17			// +----------------------------------------------------------------------+
18			//
19			// Id: Common.php,v 1.17 2003/01/28 19:18:37 cain Exp
20			// $Id: Common.php,v 1.17 2003/01/28 19:18:37 cain Exp $
21
22			require_once('Tree/OptionsDB.php');
23
24			define("TREE_ERROR", -1);
25			define("TREE_ERROR_INVALID_PARENT", -2);
26
27			/**
28			* common tree class, implements common functionality
29			*
30			* this class extends Tree_OptionsDB so every class that extends this oe can
31			* connect to a db and set options
32			*
33			* @access public
34			* @author Wolfram Kriesing <wolfram@kriesing.de>
35			* @version 2001/06/27
36			* @package Tree
37			*/
38			class Tree_Common extends Tree_OptionsDB
39			{
40
41			/**
42			* put proper value-keys are given in each class, depending on the implementation
43			* only some options are needed or allowed, see the classes which extend this one
44			*
45			* @access public
46			* @var array saves the options passed to the constructor
47			*/
48			var $options = array();
49
50
51			/**
52			*
53			*
54			* @version 2002/01/18
55			* @access public
56			* @author Wolfram Kriesing <wolfram@kriesing.de>
57			*/
58			function getChildId( $id )
59			{
60			$child = $this->getChild( $id );
61			return $child['id'];
62			}
63
64			/**
65			* get the ids of the children of the given element
66			*
67			* @version 2002/02/06
68			* @access public
69			* @author Wolfram Kriesing <wolfram@kriesing.de>
70			* @param integer $id ID of the element that the children shall be retreived for
71			* @return mixed an array of all the ids of the children of the element with id=$id,
72			* or false if there are no children
73			*/
74			function getChildrenIds( $id )
75			{
76			if( !($children = $this->getChildren( $id )) ) // returns false if no children exist
77			return array(); // return an empty array, if you want to know if there are children, use hasChildren
78
79			if( $children && sizeof($children) )
80			{
81			foreach( $children as $aChild )
82			$childrenIds[] = $aChild['id'];
83			}
84
85			return $childrenIds;
86			}
87
88			/**
89			* gets all the children and grand children etc.
90			*
91			* @version 2002/09/30
92			* @access public
93			* @author Wolfram Kriesing <wolfram@kriesing.de>
94			* @param integer $id ID of the element that the children shall be retreived for
95			* @return mixed an array of all the children of the element with id=$id,
96			* or false if there are no children
97			*/
98			function getAllChildren( $id )
99			{
100			$retChildren = false;
101			if( $children = $this->hasChildren( $id ) )
102			{
103			$retChildren = $this->_getAllChildren( $id );
104			}
105			return $retChildren;
106			}
107
108			/**
109			* this method gets all the children recursively
110			*
111			* @see getAllChildren()
112			* @version 2002/09/30
113			* @access public
114			* @author Wolfram Kriesing <wolfram@kriesing.de>
115			* @param integer $id ID of the element that the children shall be retreived for
116			* @return mixed an array of all the ids of the children of the element with id=$id,
117			* or false if there are no children
118			*/
119			function &_getAllChildren( $id )
120			{
121			$retChildren = array();
122			if( $children = $this->getChildren( $id ) )
123			{
124			foreach( $children as $key=>$aChild )
125			{
126			$retChildren[] = &$children[$key];
127			$retChildren = array_merge($retChildren,$this->_getAllChildren( $aChild['id'] ));
128			}
129			}
130			return $retChildren;
131			}
132
133			/**
134			* gets all the children-ids and grand children-ids
135			*
136			* @version 2002/09/30
137			* @access public
138			* @author Wolfram Kriesing <wolfram@kriesing.de>
139			* @param integer $id ID of the element that the children shall be retreived for
140			* @return mixed an array of all the ids of the children of the element with id=$id,
141			* or false if there are no children
142			*/
143			function getAllChildrenIds( $id )
144			{
145			$childrenIds = array();
146			if( $allChildren = $this->getAllChildren($id) )
147			{
148			$childrenIds = array();
149			foreach( $allChildren as $aNode )
150			$childrenIds[] = $aNode['id'];
151			}
152			return $childrenIds;
153			}
154			/**
155			* get the id of the parent for the given element
156			*
157			* @version 2002/01/18
158			* @access public
159			* @param integer $id the id of the element for which the parentId shall be retreived
160			* @author Wolfram Kriesing <wolfram@kriesing.de>
161			*/
162			function getParentId( $id )
163			{
164			$parent = $this->getParent( $id );
165			return $parent['id'];
166			}
167
168			/**
169			* this gets all the preceeding nodes, the parent and it's parent and so on
170			*
171			* @version 2002/08/19
172			* @access public
173			* @author Wolfram Kriesing <wolfram@kriesing.de>
174			* @param integer $id the id of the element for which the parentId shall be retreived
175			* @return array of the parent nodes including the node with id $id
176			*/
177			function getParents( $id )
178			{
179			$path = $this->getPath($id);
180			$parents = array();
181			if( sizeof($path) )
182			foreach( $path as $aNode )
183			$parents[] = $aNode;
184			return $parents;
185			}
186
187			/**
188			* get the ids of the parents and all it's parents and so on
189			* it simply returns the ids of the elements returned by getParents()
190
191			* @see getParents()
192			* @version 2002/08/19
193			* @access public
194			* @author Wolfram Kriesing <wolfram@kriesing.de>
195			* @param integer $id the id of the element for which the parentId shall be retreived
196			* @return array of the ids
197			*/
198			function getParentsIds( $id )
199			{
200			$parents = $this->getParents($id);
201			$parentsIds = array();
202			if( sizeof($parents) )
203			foreach( $parents as $aNode )
204			$parentsIds[] = $aNode['id'];
205			return $parentsIds;
206			}
207
208			/**
209			*
210			*
211			* @version 2002/01/18
212			* @access public
213			* @author Wolfram Kriesing <wolfram@kriesing.de>
214			*/
215			function getNextId( $id )
216			{
217			$next = $this->getNext( $id );
218			return $next['id'];
219			}
220
221			/**
222			*
223			*
224			* @version 2002/01/18
225			* @access public
226			* @author Wolfram Kriesing <wolfram@kriesing.de>
227			*/
228			function getPreviousId( $id )
229			{
230			$previous = $this->getPrevious( $id );
231			return $previous['id'];
232			}
233
234			/**
235			*
236			*
237			* @version 2002/01/18
238			* @access public
239			* @author Wolfram Kriesing <wolfram@kriesing.de>
240			*/
241			function getLeftId( $id )
242			{
243			$left = $this->getLeft( $id );
244			return $left['id'];
245			}
246
247			/**
248			*
249			*
250			* @version 2002/01/18
251			* @access public
252			* @author Wolfram Kriesing <wolfram@kriesing.de>
253			*/
254			function getRightId( $id )
255			{
256			$right = $this->getRight( $id );
257			return $right['id'];
258			}
259
260			/**
261			*
262			*
263			* @version 2002/01/18
264			* @access public
265			* @author Wolfram Kriesing <wolfram@kriesing.de>
266			*/
267			function getFirstRootId()
268			{
269			$firstRoot = $this->getFirstRoot();
270			return $firstRoot['id'];
271			}
272
273			/**
274			*
275			*
276			* @version 2002/04/16
277			* @access public
278			* @author Wolfram Kriesing <wolfram@kriesing.de>
279			*/
280			function getRootId()
281			{
282			$firstRoot = $this->getRoot();
283			return $firstRoot['id'];
284			}
285
286			/**
287			* returns the path as a string
288			*
289			* @access public
290			* @version 2002/03/28
291			* @access public
292			* @author Wolfram Kriesing <wolfram@kriesing.de>
293			* @param mixed $id the id of the node to get the path for
294			* @return array this array contains all elements from the root to the element given by the id
295			*
296			*/
297			function getPathAsString( $id , $seperator='/' )
298			{
299			$path = $this->getPath($id);
300			foreach( $path as $aNode )
301			$pathArray[] = $aNode['name'];
302
303			$pathString = '';
304			if( sizeof($pathArray) )
305			$pathString = implode($seperator,$pathArray);
306			return $pathString;
307			} // end of function
308
309
310
311
312
313
314			//
315			// abstract methods, those should be overwritten by the implementing class
316			//
317
318
319			/**
320			* gets the path to the element given by its id
321			*
322			* @abstract
323			* @version 2001/10/10
324			* @access public
325			* @author Wolfram Kriesing <wolfram@kriesing.de>
326			* @param mixed $id the id of the node to get the path for
327			* @return array this array contains all elements from the root to the element given by the id
328			*
329			*/
330			function getPath( $id )
331			{
332			return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
333			} // end of function
334
335			/**
336			* get the level, which is how far below the root the element with the given id is
337			*
338			* @abstract
339			* @version 2001/11/25
340			* @access public
341			* @author Wolfram Kriesing <wolfram@kriesing.de>
342			* @param mixed $id the id of the node to get the level for
343			*
344			*/
345			function getLevel( $id )
346			{
347			return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
348			} // end of function
349
350			/**
351			* returns if $childId is a child of $id
352			*
353			* @abstract
354			* @version 2002/04/29
355			* @access public
356			* @author Wolfram Kriesing <wolfram@kriesing.de>
357			* @param int id of the element
358			* @param int id of the element to check if it is a child
359			* @param boolean if this is true the entire tree below is checked
360			* @return boolean true if it is a child
361			*/
362			function isChildOf( $id , $childId , $checkAll=true )
363			{
364			return $this->_throwError( 'not implemented, at least not overwritten the abstract declaration' , __LINE__ );
365			} // end of function
366
367
368
369
370
371
372			//
373			// PRIVATE METHODS
374			//
375
376
377			/**
378			* prepare multiple results
379			*
380			* @see _prepareResult()
381			* @access private
382			* @version 2002/03/03
383			* @author Wolfram Kriesing <wolfram@kriesing.de>
384			* @param
385			* @return
386			*/
387			function _prepareResults( $results )
388			{
389			$newResults = array();
390			foreach( $results as $key=>$aResult )
391			$newResults[$key] = $this->_prepareResult($aResult);
392			return $newResults;
393			}
394
395			/**
396			* map back the index names to get what is expected
397			*
398			* @access private
399			* @version 2002/03/03
400			* @author Wolfram Kriesing <wolfram@kriesing.de>
401			* @param
402			* @return
403			*/
404			function _prepareResult( $result )
405			{
406			$map = $this->getOption('columnNameMaps');
407
408			if( $map )
409			foreach( $map as $key=>$columnName )
410			{
411			$result[$key] = $result[$columnName];
412			unset($result[$columnName]);
413			}
414			return $result;
415			}
416
417			/**
418			* this method retreives the real column name, as used in the DB
419			* since the internal names are fixed, to be portable between different
420			* DB-column namings, we map the internal name to the real column name here
421			*
422			* @access private
423			* @version 2002/03/02
424			* @author Wolfram Kriesing <wolfram@kriesing.de>
425			* @param
426			* @return
427			*/
428			function _getColName( $internalName )
429			{
430			if( $map = $this->getOption( 'columnNameMaps' ) )
431			{
432			if( isset($map[$internalName]) )
433			return $map[$internalName];
434			}
435			return $internalName;
436			}
437
438			/**
439			*
440			*
441			* @access private
442			* @version 2002/03/02
443			* @author Wolfram Kriesing <wolfram@kriesing.de>
444			* @param
445			* @return
446			*/
447			function _throwError( $msg , $line , $mode=null )
448			{
449			if( $mode===null && $this->debug>0 )
450			$mode = PEAR_ERROR_PRINT;
451			return new Tree_Error( $msg , $line , __FILE__ , $mode , $this->dbh->last_query );
452			}
453
454			}
455			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26