widgets/data_list/ArrayDataListSource.inc

<?php
/**
 * $Id: ArrayDataListSource.inc,v 1.9 2004/02/09 23:02:36 hemna Exp $
 *
 * This file contains the DataListSource class
 * that gets the data from an array
 *
 * @author Suren Markossian <suren_markossian@yahoo.com>
 * @package phpHtmlLib
 */

/**
 * We require the DataListSource
 */
require_once($phphtmllib."/widgets/data_list/DataListSource.inc");


/**
 *
 * This DataListSource child class gets the data from an
 * external array
 *
 * The array is a 2D array and each sub-array is a set of elements for
 * each row in the list
 *
 * @author Suren Markossian <suren_markossian@yahoo.com>
 * @package phpHtmlLib
 */
class ArrayDataListSource extends DataListSource {


    /**
     * The constructor.
     *
     * @param array data - an array of array elements for each row
     */
    function ArrayDataListSource(&$data) {
        $this->_data = $data;
    }

    /**
     * This function does the query
     * and search/sort
     */
    function do_query() {

        // do data pre-processing if neccessary
        if ($this->get_searchby_value()) {
            $this->_prequery_filter();
        }

        $count = count($this->_data);

        if ($count > 0) {
            $this->set_total_rows($count);
            $this->sort();
            return true;
        } else {
            return false;
        }
    }

    /**
     * This is a method that should be defined by the
     * child class to do any pre-query type of things.
     * Such as building a sql query string for a DB,
     * or checking to make sure the file on disk exists
     * if the source is a file on disk.
     *
     */
    function do_prequery() {
        return NULL;
    }

    /**
     * This function returns the next row of
     * valid data.
     *
     */
    function get_next_data_row() {
        $index = $this->get_data_index();
        $limit = $this->get_limit();
        $offset = $this->get_offset();

        if ($limit == -1) {
            // don't limit the data
            if ($index > $this->get_total_rows()) {
                return NULL;
            } else {
                return $this->_data[$index];
            }
        } else {
            // Check if we are still in the display range
            if (!is_null($index) && $index < $limit && isset($this->_data[$offset + $index])) {
                return $this->_data[$offset + $index];
            } else {
                return NULL;
            }
        }
    }

    /**
     * This is used to perform pre-query filtering
     * Gives us a chance to run the next row through a filter
     * before any processing has been done
     *
     * @param array - the row to run through the filter
     *
     * @return boolean - TRUE = allow the row. FALSE = drop it.
     */
    function prequery_row_filter(&$row_data) {
        return $this->_find_data($row_data);
    }

    /**
     * This is called to allow rebuilding the data array
     * to remove elements that have to be filtered
     *
     * This is done on pre-processing phase and used for
     * simple and advanced searches
     *
     */
    function _prequery_filter() {

        while (list($key,$row_data) = each($this->_data)) {
            if (!$this->prequery_row_filter($row_data)) {
                unset($this->_data[$key]);
            }
        }

        // re-index the array
        $this->_data = array_values($this->_data);
    }

    /**
     * This function returns the
     * data_index value and increments it
     *
     * @return int
     */
    function get_data_index() {
        $this->_data_index = key($this->_data);
        next($this->_data);
        return $this->_data_index;
    }

    /**
     * This method sorts our data array by the requested
     * column order by.  This could be expensive for HUGE
     * arrays.
     * 
     * @return none
     */
    function sort() {
        $sortby = $this->get_orderby();

        $column_name = NULL;
        // get the column name
        foreach($this->_columns as $name => $data) {
            if ($sortby == $data["data_name"]) {
                $column_name = $name;
                break;
            }
        }

        // we need to sort the data by the
        // column in the table
        if ($column_name != NULL && $this->_columns[$column_name]["sortable"] != NOT_SORTABLE) {
            // looks like we can sort this column
            if ($this->_columns[$column_name]["sortable"] == SORTABLE_NUMERIC) {
                usort($this->_data, array($this, "cmp_numeric"));
            } else {
                usort($this->_data, array($this, "cmp"));
            }
        }
    }

    /**
     * This method is used for comparing 2 string values
     * 
     * @param string first entry to compare
     * @param string second entry to compare
     * @return natural compare results
     */
    function cmp($data1, $data2) {
        $sortby = $this->get_orderby();

        $ret = strnatcmp( $data1[$sortby], $data2[$sortby]);

        if ($this->get_reverseorder() == "true") {
            $ret *= -1;
        }
        return $ret;
    }

    /**
     * This method is used for comparing 2 numerical 
     * values
     * 
     * @param string first entry to compare
     * @param string second entry to compare
     * @return compare results
     */
    function cmp_numeric($data1, $data2) {

        $sortby = $this->get_orderby();
        if ($data1[$sortby]==$data2[$sortby]) $ret = 0;
        else $ret = ($data1[$sortby] < $data2[$sortby]) ? -1 : 1;

        if ($this->get_reverseorder() == "true") {
            $ret *= -1;
        }
        return $ret;
    }

    /**
     * This is used to do the default search
     * capability in the DataListSource parent class.
     * This is used so we can filter our results to 
     * what the user searched for.
     * 
     * @param array the row data entry.
     *              We will look for a specific column's 
     *              value here to test against.
     * @return boolean found it or not
     */
    function _find_data( $row_data ) {
                //look for the 'needle' in the 'haystack'

                $needle = $this->get_searchby_value();
                $haystack = $row_data[$this->get_searchby()];

                switch ($this->get_simplesearch_modifier()) {
                case "BEGINS":
                        if (strncasecmp($needle, $haystack, strlen($needle)) == 0) {
                                return TRUE;
                        } else {
                                return FALSE;
                        }
                        break;

                case "CONTAINS":
                        if (stristr($haystack, $needle)) {
                                return TRUE;
                        } else {
                                return FALSE;
                        }
                        break;
                case "EXACT":
                        if (strcasecmp($needle, $haystack) == 0) {
                                return TRUE;
                        } else {
                                return FALSE;
                        }
                        break;
                case "ENDS":
                        $needle_len = strlen( $needle );
                        $haystack_len = strlen( $haystack );
                        if ($needle_len > $haystack_len) {
                                return FALSE;
                        } else if ($needle_len == $haystack_len) {
                                $tmp = $haystack;
                        } else {
                                $tmp = substr($haystack, $haystack_len - $needle_len);
                        }
                        if (strncasecmp($needle, $tmp, $needle_len) == 0) {
                                return TRUE;
                        } else {
                                return FALSE;
                        }
                        break;
                }
        }

}
?>
1	<?php
2	/**
3	* $Id: ArrayDataListSource.inc,v 1.9 2004/02/09 23:02:36 hemna Exp $
4	*
5	* This file contains the DataListSource class
6	* that gets the data from an array
7	*
8	* @author Suren Markossian <suren_markossian@yahoo.com>
9	* @package phpHtmlLib
10	*/
11
12	/**
13	* We require the DataListSource
14	*/
15	require_once($phphtmllib."/widgets/data_list/DataListSource.inc");
16
17
18	/**
19	*
20	* This DataListSource child class gets the data from an
21	* external array
22	*
23	* The array is a 2D array and each sub-array is a set of elements for
24	* each row in the list
25	*
26	* @author Suren Markossian <suren_markossian@yahoo.com>
27	* @package phpHtmlLib
28	*/
29	class ArrayDataListSource extends DataListSource {
30
31
32	/**
33	* The constructor.
34	*
35	* @param array data - an array of array elements for each row
36	*/
37	function ArrayDataListSource(&$data) {
38	$this->_data = $data;
39	}
40
41	/**
42	* This function does the query
43	* and search/sort
44	*/
45	function do_query() {
46
47	// do data pre-processing if neccessary
48	if ($this->get_searchby_value()) {
49	$this->_prequery_filter();
50	}
51
52	$count = count($this->_data);
53
54	if ($count > 0) {
55	$this->set_total_rows($count);
56	$this->sort();
57	return true;
58	} else {
59	return false;
60	}
61	}
62
63	/**
64	* This is a method that should be defined by the
65	* child class to do any pre-query type of things.
66	* Such as building a sql query string for a DB,
67	* or checking to make sure the file on disk exists
68	* if the source is a file on disk.
69	*
70	*/
71	function do_prequery() {
72	return NULL;
73	}
74
75	/**
76	* This function returns the next row of
77	* valid data.
78	*
79	*/
80	function get_next_data_row() {
81	$index = $this->get_data_index();
82	$limit = $this->get_limit();
83	$offset = $this->get_offset();
84
85	if ($limit == -1) {
86	// don't limit the data
87	if ($index > $this->get_total_rows()) {
88	return NULL;
89	} else {
90	return $this->_data[$index];
91	}
92	} else {
93	// Check if we are still in the display range
94	if (!is_null($index) && $index < $limit && isset($this->_data[$offset + $index])) {
95	return $this->_data[$offset + $index];
96	} else {
97	return NULL;
98	}
99	}
100	}
101
102	/**
103	* This is used to perform pre-query filtering
104	* Gives us a chance to run the next row through a filter
105	* before any processing has been done
106	*
107	* @param array - the row to run through the filter
108	*
109	* @return boolean - TRUE = allow the row. FALSE = drop it.
110	*/
111	function prequery_row_filter(&$row_data) {
112	return $this->_find_data($row_data);
113	}
114
115	/**
116	* This is called to allow rebuilding the data array
117	* to remove elements that have to be filtered
118	*
119	* This is done on pre-processing phase and used for
120	* simple and advanced searches
121	*
122	*/
123	function _prequery_filter() {
124
125	while (list($key,$row_data) = each($this->_data)) {
126	if (!$this->prequery_row_filter($row_data)) {
127	unset($this->_data[$key]);
128	}
129	}
130
131	// re-index the array
132	$this->_data = array_values($this->_data);
133	}
134
135	/**
136	* This function returns the
137	* data_index value and increments it
138	*
139	* @return int
140	*/
141	function get_data_index() {
142	$this->_data_index = key($this->_data);
143	next($this->_data);
144	return $this->_data_index;
145	}
146
147	/**
148	* This method sorts our data array by the requested
149	* column order by. This could be expensive for HUGE
150	* arrays.
151	*
152	* @return none
153	*/
154	function sort() {
155	$sortby = $this->get_orderby();
156
157	$column_name = NULL;
158	// get the column name
159	foreach($this->_columns as $name => $data) {
160	if ($sortby == $data["data_name"]) {
161	$column_name = $name;
162	break;
163	}
164	}
165
166	// we need to sort the data by the
167	// column in the table
168	if ($column_name != NULL && $this->_columns[$column_name]["sortable"] != NOT_SORTABLE) {
169	// looks like we can sort this column
170	if ($this->_columns[$column_name]["sortable"] == SORTABLE_NUMERIC) {
171	usort($this->_data, array($this, "cmp_numeric"));
172	} else {
173	usort($this->_data, array($this, "cmp"));
174	}
175	}
176	}
177
178	/**
179	* This method is used for comparing 2 string values
180	*
181	* @param string first entry to compare
182	* @param string second entry to compare
183	* @return natural compare results
184	*/
185	function cmp($data1, $data2) {
186	$sortby = $this->get_orderby();
187
188	$ret = strnatcmp( $data1[$sortby], $data2[$sortby]);
189
190	if ($this->get_reverseorder() == "true") {
191	$ret *= -1;
192	}
193	return $ret;
194	}
195
196	/**
197	* This method is used for comparing 2 numerical
198	* values
199	*
200	* @param string first entry to compare
201	* @param string second entry to compare
202	* @return compare results
203	*/
204	function cmp_numeric($data1, $data2) {
205
206	$sortby = $this->get_orderby();
207	if ($data1[$sortby]==$data2[$sortby]) $ret = 0;
208	else $ret = ($data1[$sortby] < $data2[$sortby]) ? -1 : 1;
209
210	if ($this->get_reverseorder() == "true") {
211	$ret *= -1;
212	}
213	return $ret;
214	}
215
216	/**
217	* This is used to do the default search
218	* capability in the DataListSource parent class.
219	* This is used so we can filter our results to
220	* what the user searched for.
221	*
222	* @param array the row data entry.
223	* We will look for a specific column's
224	* value here to test against.
225	* @return boolean found it or not
226	*/
227	function _find_data( $row_data ) {
228	//look for the 'needle' in the 'haystack'
229
230	$needle = $this->get_searchby_value();
231	$haystack = $row_data[$this->get_searchby()];
232
233	switch ($this->get_simplesearch_modifier()) {
234	case "BEGINS":
235	if (strncasecmp($needle, $haystack, strlen($needle)) == 0) {
236	return TRUE;
237	} else {
238	return FALSE;
239	}
240	break;
241
242	case "CONTAINS":
243	if (stristr($haystack, $needle)) {
244	return TRUE;
245	} else {
246	return FALSE;
247	}
248	break;
249	case "EXACT":
250	if (strcasecmp($needle, $haystack) == 0) {
251	return TRUE;
252	} else {
253	return FALSE;
254	}
255	break;
256	case "ENDS":
257	$needle_len = strlen( $needle );
258	$haystack_len = strlen( $haystack );
259	if ($needle_len > $haystack_len) {
260	return FALSE;
261	} else if ($needle_len == $haystack_len) {
262	$tmp = $haystack;
263	} else {
264	$tmp = substr($haystack, $haystack_len - $needle_len);
265	}
266	if (strncasecmp($needle, $tmp, $needle_len) == 0) {
267	return TRUE;
268	} else {
269	return FALSE;
270	}
271	break;
272	}
273	}
274
275	}
276	?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26