steffen: server/kolab-horde-framework/kolab-horde-framework/Util Array.php, NONE, 1.1 String.php, NONE, 1.1 Util.php, NONE, 1.1 Variables.php, NONE, 1.1 package.xml, NONE, 1.1
cvs at intevation.de
cvs at intevation.de
Fri Oct 14 16:33:16 CEST 2005
- Previous message: steffen: server/kolab-horde-framework/kolab-horde-framework/UI/UI Language.php, NONE, 1.1 Pager.php, NONE, 1.1 Table.php, NONE, 1.1 Tabs.php, NONE, 1.1 VarRenderer.php, NONE, 1.1 Widget.php, NONE, 1.1
- Next message: steffen: server/kolab-horde-framework/kolab-horde-framework/Util/tests String.phpt, NONE, 1.1 String2.phpt, NONE, 1.1 utf-8.phpt, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Author: steffen
Update of /kolabrepository/server/kolab-horde-framework/kolab-horde-framework/Util
In directory doto:/tmp/cvs-serv28903/kolab-horde-framework/kolab-horde-framework/Util
Added Files:
Array.php String.php Util.php Variables.php package.xml
Log Message:
Separated Horde Framework from kolab-resource-handlers
--- NEW FILE: Array.php ---
<?php
/**
* The Horde_Array:: class provides various methods for array manipulation.
*
* $Horde: framework/Util/Array.php,v 1.21 2004/04/22 18:38:27 chuck Exp $
*
* Copyright 2003-2004 Michael Slusarz <slusarz at bigworm.colorado.edu>
* Copyright 2003-2004 Marko Djukic <marko at oblo.com>
* Copyright 2003-2004 Jan Schneider <jan at horde.org>
*
* See the enclosed file COPYING for license information (LGPL). If you
* did not receive this file, see http://www.fsf.org/copyleft/lgpl.html.
*
* @author Michael Slusarz <slusarz at bigworm.colorado.edu>
* @author Marko Djukic <marko at oblo.com>
* @author Jan Schneider <jan at horde.org>
* @version $Revision: 1.1 $
* @since Horde 3.0
* @package Horde_Util
*/
class Horde_Array {
/**
* Prepare a list of addresses for storage.
* Namely, trims and lowercases all addresses and then sort.
*
* @access public
*
* @param array $addr The list of addresses.
*
* @return array The list of addresses, prepared for storage.
*/
function prepareAddressList($addr)
{
/* Remove any extra space in the address and make it lowercase. */
$addr = array_map('trim', $addr);
$addr = array_map(array('String', 'lower'), $addr);
/* Remove duplicate entries. */
$addr = array_unique($addr);
/* Sort the list. */
usort($addr, array('Horde_Array', 'sortAddressList'));
return $addr;
}
/**
* Function used by usort() to sort an address list.
* e.g. usort($foo, array('Horde_Array', 'sortAddressList'));
*
* @access public
*
* @param string $a Address #1.
* @param string $b Address #2.
*
* @return integer -1, 0, or 1.
*/
function sortAddressList($a, $b)
{
$a = explode('@', $a);
$b = explode('@', $b);
/* One of the addresses doesn't have a host name. */
if (empty($a[0])) {
array_shift($a);
}
if (empty($b[0])) {
array_shift($b);
}
if (count($a) != count($b)) {
return (count($a) > count($b));
}
/* The addresses have different hostname or not hostname and
different mailbox names. */
if ($a[(count($a) - 1)] != $b[(count($b) - 1)]) {
return strcmp($a[(count($a) - 1)], $b[(count($b) - 1)]);
}
/* Compare mailbox names. */
return strcmp($a[0], $b[0]);
}
/**
* Sorts an array on a specified key. If the key does not exist,
* defaults to the first key of the array.
*
* @access public
*
* @param array &$array The array to be sorted, passed
* by reference.
* @param optional string $key The key by which to sort. If not
* specified then the first key is
* used.
* @param optional integer $direction Sort direction
* 0 = ascending (default)
* 1 = descending
*/
function arraySort(&$array, $key = null, $direction = 0)
{
/* Return if the array is empty. */
if (empty($array)) {
return;
}
/* If no key to sort by is specified, use the first key. */
if (is_null($key)) {
$keys = array_keys($array);
$key = $keys[0];
}
/* Create the function that will be used to sort the keys. */
$function = sprintf('return String::lower($a[\'%1$s\']) %2$s String::lower($b[\'%1$s\']) ? 1 : -1;', $key, ($direction ? '<' : '>'));
/* Call the sort function, preserving array key
* association. */
uasort($array, create_function('$a, $b', $function));
}
/**
* Given an HTML type array field "example[key1][key2][key3]" breaks up
* the keys so that they could be used to reference a regular PHP array.
*
* @access public
*
* @param string $field The field name to be examined.
* @param string &$base Set to the base element.
* @param array &$keys Set to the list of keys.
*
* @access boolean True on sucess, false on error.
*/
function getArrayParts($field, &$base, &$keys)
{
if (preg_match('|([^\[]*)((\[[^\[\]]*\])+)|', $field, $matches)) {
$base = $matches[1];
$keys = explode('][', $matches[2]);
$keys[0] = substr($keys[0], 1);
$keys[count($keys) - 1] = substr($keys[count($keys) - 1], 0, strlen($keys[count($keys) - 1]) - 1);
return true;
} else {
return false;
}
}
/**
* Using an array of keys itarate through the array following the keys to
* find the final key value. If a value is passed then set that value.
*
* @access public
*
* @param array &$array The array to be used.
* @param array &$keys The key path to follow as an array.
* @param optional array $value If set the target element will have this
* value set to it.
*
* @returns mixed The final value of the key path.
*/
function getElement(&$array, &$keys, $value = null)
{
if (count($keys) > 0) {
$key = array_shift($keys);
if (isset($array[$key])) {
return Horde_Array::getElement($array[$key], $keys, $value);
} else {
return $array;
}
} else {
if (!is_null($value)) {
$array = $value;
}
return $array;
}
}
/**
* Returns a rectangle of a two-dimensional array.
*
* @access public
*
* @param array &$array The array to extract the rectangle from.
* @param integer $row The start row of the rectangle.
* @param integer $col The start column of the rectangle.
* @param integer $height The height of the rectangle.
* @param integer $width The width of the rectangle.
*
* @return array The extracted rectangle.
*/
function &getRectangle(&$array, $row, $col, $height, $width)
{
$rec = array();
for ($y = $row; $y < $row + $height; $y++) {
$rec[] = array_slice($array[$y], $col, $width);
}
return $rec;
}
/**
* Given an array, returns an associative array with each element key
* derived from its value.
* For example:
* array(0 => 'foo', 1 => 'bar')
* would become:
* array('foo' => 'foo', 'bar' => 'bar')
*
* @access public
*
* @param array $array An array of values.
*
* @return array An array with keys the same as values.
*/
function valuesToKeys($array)
{
$mapped = array();
foreach ($array as $value) {
$mapped[$value] = $value;
}
return $mapped;
}
/**
* Creates an array by using one array for keys and another for
* its values. Only exists in PHP5, so we call array_combine if it
* exists and otherwise emulate it.
*
* @param array $keys Key array.
* @param array $values Value array.
*
* @return mixed False if there are no elements, or the combined array.
*/
function combine($keys, $values)
{
if (function_exists('array_combine')) {
return array_combine($keys, $values);
}
$size = count($keys);
if (($size != count($values)) || ($size == 0)) {
return false;
}
for ($x = 0; $x < $size; $x++) {
$array[$keys[$x]] = $values[$x];
}
return $array;
}
}
--- NEW FILE: String.php ---
<?php
$GLOBALS['_HORDE_STRING_CHARSET'] = 'iso-8859-1';
/**
* The String:: class provides static methods for charset and locale safe
* string manipulation.
*
* $Horde: framework/Util/String.php,v 1.33 2004/05/04 11:17:42 jan Exp $
*
* Copyright 2003-2004 Jan Schneider <jan at horde.org>
*
* See the enclosed file COPYING for license information (LGPL). If you
* did not receive this file, see http://www.fsf.org/copyleft/lgpl.html.
*
* @author Jan Schneider <jan at horde.org>
* @version $Revision: 1.1 $
* @since Horde 3.0
* @package Horde_Util
*/
class String {
/**
* Sets a default charset that the String:: methods will use if none is
* explicitely specified.
*
* @param string $charset The charset to use as the default one.
*/
function setDefaultCharset($charset)
{
$GLOBALS['_HORDE_STRING_CHARSET'] = $charset;
}
/**
* Converts a string from one charset to another.
*
* Works only if either the iconv or the mbstring extension
* are present and best if both are available.
* The original string is returned if conversion failed or none
* of the extensions were available.
*
* @param mixed $input The data to be converted. If $input is an an
* array, the array's values get converted recursively.
* @param string $from The string's current charset.
* @param string $to (optional) The charset to convert the string to. If
* not specified, the global variable
* $_HORDE_STRING_CHARSET will be used.
*
* @return string The converted string.
*/
function convertCharset($input, $from, $to = null)
{
if (is_array($input)) {
$tmp = array();
foreach ($input as $key => $val) {
$tmp[String::convertCharset($key, $from, $to)] = String::convertCharset($val, $from, $to);
}
return $tmp;
}
if (is_object($input)) {
$vars = get_object_vars($input);
foreach ($vars as $key => $val) {
$input->$key = String::convertCharset($val, $from, $to);
}
return $input;
}
if (!is_string($input)) {
return $input;
}
$output = false;
/* Get the user's default character set if none passed in. */
if (is_null($to)) {
$to = $GLOBALS['_HORDE_STRING_CHARSET'];
}
/* If the from and to chaacter sets are identical, return now. */
$str_from = String::lower($from);
$str_to = String::lower($to);
if ($str_from == $str_to) {
return $input;
}
/* Use utf8_[en|de]code() if possible. */
$str_from_check = (($str_from == 'iso-8859-1') || ($str_from == 'us-ascii'));
if ($str_from_check && ($str_to == 'utf-8')) {
return utf8_encode($input);
}
$str_to_check = (($str_to == 'iso-8859-1') || ($str_to == 'us-ascii'));
if (($str_from == 'utf-8') && $str_to_check) {
return utf8_decode($input);
}
/* First try iconv with transliteration. */
if ($str_from != 'utf7-imap' &&
$str_to != 'utf7-imap' &&
Util::extensionExists('iconv')) {
ini_set('track_errors', 1);
/* We need to tack an extra character temporarily
because of a bug in iconv() if the last character
is not a 7 bit ASCII character. */
$output = @iconv($from, $to . '//TRANSLIT', $input . 'x');
if (isset($php_errormsg)) {
$output = false;
} else {
$output = String::substr($output, 0, -1, $to);
}
ini_restore('track_errors');
}
/* Next try mbstring. */
if (!$output && Util::extensionExists('mbstring')) {
$output = @mb_convert_encoding($input, $to, $from);
}
/* At last try imap_utf7_[en|de]code if appropriate. */
if (!$output && Util::extensionExists('imap')) {
if ($str_from_check && ($str_to == 'utf7-imap')) {
return @imap_utf7_encode($input);
}
if (($str_from == 'utf7-imap') && $str_to_check) {
return @imap_utf7_decode($input);
}
}
return (!$output) ? $input : $output;
}
/**
* Makes a string lowercase.
*
* @param string $string The string to be converted.
* @param bool $locale (optional) If true the string will be converted
* based on a given charset, locale independent else.
* @param string $charset (optional) If $locale is true, the charset to use
* when converting. If not provided the current
* charset.
*
* @return string The string with lowercase characters
*/
function lower($string, $locale = false, $charset = null)
{
static $lowers;
if ($locale) {
/* The existence of mb_strtolower() depends on the platform. */
if (Util::extensionExists('mbstring') &&
function_exists('mb_strtolower')) {
if (is_null($charset)) {
$charset = $GLOBALS['_HORDE_STRING_CHARSET'];
}
$ret = @mb_strtolower($string, $charset);
if (!empty($ret)) {
return $ret;
}
}
return strtolower($string);
}
if (!isset($lowers)) {
$lowers = array();
}
if (!isset($lowers[$string])) {
$language = setlocale(LC_CTYPE, 0);
setlocale(LC_CTYPE, 'en');
$lowers[$string] = strtolower($string);
setlocale(LC_CTYPE, $language);
}
return $lowers[$string];
}
/**
* Makes a string uppercase.
*
* @param string $string The string to be converted.
* @param bool $locale (optional) If true the string will be converted
* based on a given charset, locale independent else.
* @param string $charset (optional) If $locale is true, the charset to use
* when converting. If not provided the current
* charset.
*
* @return string The string with uppercase characters
*/
function upper($string, $locale = false, $charset = null)
{
static $uppers;
if ($locale) {
/* The existence of mb_strtoupper() depends on the platform. */
if (Util::extensionExists('mbstring') &&
function_exists('mb_strtoupper')) {
if (is_null($charset)) {
$charset = $GLOBALS['_HORDE_STRING_CHARSET'];
}
$ret = @mb_strtoupper($string, $charset);
if (!empty($ret)) {
return $ret;
}
}
return strtoupper($string);
}
if (!isset($uppers)) {
$uppers = array();
}
if (!isset($uppers[$string])) {
$language = setlocale(LC_CTYPE, 0);
setlocale(LC_CTYPE, 'en');
$uppers[$string] = strtoupper($string);
setlocale(LC_CTYPE, $language);
}
return $uppers[$string];
}
/**
* Returns part of a string.
*
* @param string $string The string to be converted.
* @param int $start The part's start position, zero based.
* @param int $length (optional) The part's length.
* @param string $charset (optional) The charset to use when calculating
* the part's position and length, defaults to
* current charset.
*
* @return string The string's part.
*/
function substr($string, $start, $length = null, $charset = null)
{
if (Util::extensionExists('mbstring')) {
if (is_null($charset)) {
$charset = $GLOBALS['_HORDE_STRING_CHARSET'];
}
if (is_null($length)) {
$length = String::length($string, $charset);
}
$ret = @mb_substr($string, $start, $length, $charset);
if (!empty($ret)) {
return $ret;
}
}
if (is_null($length)) {
$length = String::length($string);
}
return substr($string, $start, $length);
}
/**
* Returns the character (not byte) length of a string.
*
* @param string $string The string to return the length of.
* @param string $charset (optional) The charset to use when calculating
* the string's length.
*
* @return string The string's part.
*/
function length($string, $charset = null)
{
if (Util::extensionExists('mbstring')) {
if (is_null($charset)) {
$charset = $GLOBALS['_HORDE_STRING_CHARSET'];
}
$ret = @mb_strlen($string, $charset);
if (!empty($ret)) {
return $ret;
}
}
return strlen($string);
}
/**
* Returns the numeric position of the first occurrence of $needle in
* the $haystack string.
*
* @param string $haystack The string to search through.
* @param string $needle The string to search for.
* @param int $offset (optional) Allows to specify which character in
* haystack to start searching.
* @param string $charset (optional) The charset to use when searching
* for the $needle string.
*
* @return int The position of first occurrence.
*/
function pos($haystack, $needle, $offset = 0, $charset = null)
{
if (Util::extensionExists('mbstring')) {
if (is_null($charset)) {
$charset = $GLOBALS['_HORDE_STRING_CHARSET'];
}
ini_set('track_errors', 1);
$ret = @mb_strpos($haystack, $needle, $offset, $charset);
ini_restore('track_errors');
if (!isset($php_errormsg)) {
return $ret;
}
}
return strpos($haystack, $needle, $offset);
}
function isAlpha($string, $charset = null)
{
return ctype_alpha($string);
}
/**
* Returns true if every character in the parameter is a lowercase
* letter in the current locale.
*
* @param $string The string to test.
* @param $charset (optional) The charset to use when testing the string.
*
* @return bool True if the parameter was lowercase.
*/
function isLower($string, $charset = null)
{
return ((String::lower($string, true, $charset) === $string) &&
String::isAlpha($string, $charset));
}
/**
* Returns true if every character in the parameter is an uppercase
* letter in the current locale.
*
* @param string $string The string to test.
* @param string $charset (optional) The charset to use when testing the string.
*
* @return boolean True if the parameter was uppercase.
*/
function isUpper($string, $charset = null)
{
return ((String::upper($string, true, $charset) === $string) &&
String::isAlpha($string, $charset));
}
}
--- NEW FILE: Util.php ---
<?php
/**
* Error code for a missing driver configuration.
*/
define('HORDE_ERROR_DRIVER_CONFIG_MISSING', 1);
/**
* Error code for an incomplete driver configuration.
*/
define('HORDE_ERROR_DRIVER_CONFIG', 2);
/**
* The Util:: class provides generally useful methods of different kinds.
*
* $Horde: framework/Util/Util.php,v 1.371 2004/04/29 20:05:02 slusarz Exp $
*
* Copyright 1999-2004 Chuck Hagenbuch <chuck at horde.org>
* Copyright 1999-2004 Jon Parise <jon at horde.org>
*
* See the enclosed file COPYING for license information (LGPL). If you
* did not receive this file, see http://www.fsf.org/copyleft/lgpl.html.
*
* @author Chuck Hagenbuch <chuck at horde.org>
* @author Jon Parise <jon at horde.org>
* @version $Revision: 1.1 $
* @since Horde 3.0
* @package Horde_Util
*/
class Util {
/**
* Returns an object's clone.
*
* @param object &$obj The object to clone.
*
* @return object The cloned object.
*/
function &cloneObject(&$obj)
{
if (version_compare(zend_version(), '2', '>')) {
return clone($obj);
} else {
$newObj = $obj;
return $newObj;
}
}
/**
* Buffer the output from a function call, like readfile() or
* highlight_string(), that prints the output directly, so that
* instead it can be returned as a string and used.
*
* @access public
*
* @param string $function The function to run.
* @param optional mixed $arg1 First argument to $function().
* @param optional mixed $arg2 Second argument to $function().
* @param optional mixed $arg... ...
* @param optional mixed $argN Nth argument to $function().
*
* @return string The output of the function.
*/
function bufferOutput()
{
if (func_num_args() == 0) {
return false;
}
$eval = false;
$args = func_get_args();
$function = array_shift($args);
if (is_array($function)) {
if (!is_callable($function)) {
return false;
}
} elseif (($function == 'include') ||
($function == 'include_once') ||
($function == 'require') ||
($function == 'require_once')) {
$eval = true;
} elseif (!function_exists($function) &&
($function != 'eval')) {
return false;
}
ob_start();
if ($eval) {
eval($function . " '" . implode(',', $args) . "';");
} elseif ($function == 'eval') {
eval($args[0]);
} else {
call_user_func_array($function, $args);
}
$output = ob_get_contents();
ob_end_clean();
return $output;
}
/**
* Check to see if a value has been set by the script and not by GET,
* POST, or cookie input. The value being checked MUST be in the global
* scope.
*
* @access public
*
* @param string $varname The variable name to check.
*
* @return mixed Null if the var is in user input, the variable value
* otherwise.
*/
function nonInputVar($varname)
{
if (isset($_GET[$varname]) ||
isset($_POST[$varname]) ||
isset($_COOKIE[$varname])) {
return null;
} else {
return isset($GLOBALS[$varname]) ? $GLOBALS[$varname] : null;
}
}
/**
* Add a name=value pair to the end of an URL, taking care of whether
* there are existing parameters and whether to use ? or & as the glue.
* All data will be urlencoded.
*
* @access public
*
* @param string $url The URL to modify
* @param mixed $parameter Either the name=value pair to add
* (DEPRECATED) -or-
* the name value -or-
* an array of name/value pairs.
* @param optional string $value If specified, the value part ($parameter
* is then assumed to just be the parameter
* name).
*
* @return string The modified URL.
*
* @since Horde 2.1
*/
function addParameter($url, $parameter, $value = null)
{
if (empty($parameter)) {
return $url;
}
$arg = ini_get('arg_separator.output');
if (!is_array($parameter)) {
/* This is deprecated should be removed in the future. */
if (is_null($value)) {
@list($parameter, $value) = explode('=', $parameter, 2);
}
$add = array($parameter => $value);
} else {
$add = $parameter;
}
if (($pos = strpos($url, '?')) === false) {
$url .= '?';
} else {
/* Check if the argument separator has been already
* htmlentities-ized in the URL. */
$query = substr($url, $pos + 1);
if (preg_match('/=.*?' . htmlentities($arg) . '.*?=/', $query)) {
$arg = htmlentities($arg);
$query = strtr($query, array_flip(get_html_translation_table(HTML_ENTITIES)));
}
parse_str($query, $params);
$url .= $arg;
}
$url_params = array();
foreach ($add as $parameter => $value) {
if (!isset($params[$parameter])) {
$url_params[] = urlencode($parameter) . '=' . urlencode($value);
}
}
return $url . join($arg, $url_params);
}
/**
* Removes name=value pairs from a URL.
*
* @access public
*
* @param string $url The URL to modify.
* @param mixed $remove Either a single parameter to remove or an array
* of parameters to remove.
*
* @return string The modified URL.
*
* @since Horde 2.2
*/
function removeParameter($url, $remove)
{
if (!is_array($remove)) {
$remove = array($remove);
}
/* Return immediately if there are no parameters to remove. */
if (($pos = strpos($url, '?')) === false) {
return $url;
}
$arg = ini_get('arg_separator.output');
$entities = false;
list($url, $query) = explode('?', $url, 2);
/* Check if the argument separator has been already
* htmlentities-ized in the URL. */
if (preg_match('/=.*?' . htmlentities($arg) . '.*?=/', $query)) {
$entities = true;
$query = strtr($query, array_flip(get_html_translation_table(HTML_ENTITIES)));
}
/* Get the list of parameters. */
parse_str($query, $params);
/* Remove the parameters. */
foreach ($remove as $param) {
unset($params[$param]);
}
if (!count($params)) {
return $url;
}
/* Flatten arrays.
* FIXME: should handle more than one array level somehow. */
$keys = array();
$vals = array();
foreach ($params as $key => $val) {
if (is_array($val)) {
foreach ($val as $v) {
$keys[] = $key . '[]';
$vals[] = $v;
}
} else {
$keys[] = $key;
$vals[] = $val;
}
}
$query = implode($arg, array_map(create_function('$a,$b', 'return str_replace(urlencode("[]"), "[]", urlencode($a)) . "=" . urlencode($b);'), $keys, $vals));
if ($entities) {
$query = htmlentities($query);
}
return $url . '?' . $query;
}
/**
* Returns a url with the 'nocache' parameter added, if the browser is
* buggy and caches old URLs.
*
* @access public
*
* @param string $url The URL to modify.
*
* @return string The requested URI.
*/
function nocacheUrl($url)
{
static $rand_num;
// FIXME: load from include_path.
require_once 'Horde/Browser.php';
$browser = &Browser::singleton();
if (!isset($rand_num)) {
$rand_num = base_convert(microtime(), 10, 36);
}
/* We may need to set a dummy parameter 'nocache' since some
* browsers do not always honor the 'no-cache' header. */
if ($browser->hasQuirk('cache_same_url')) {
return Util::addParameter($url, 'nocache', $rand_num);
} else {
return $url;
}
}
/**
* Return a hidden form input containing the session name and id.
*
* @access public
*
* @param optional boolean $append_session 0 = only if needed, 1 = always.
*
* @return string The hidden form input, if needed/requested.
*/
function formInput($append_session = 0)
{
if (($append_session == 1) ||
!array_key_exists(session_name(), $_COOKIE)) {
return '<input type="hidden" name="' . session_name() . '" value="' . session_id() . "\" />\n";
} else {
return '';
}
}
/**
* Print a hidden form input containing the session name and id.
*
* @access public
*
* @param optional boolean $append_session 0 = only if needed, 1 = always.
*
* @return string The hidden form input, if needed/requested.
*/
function pformInput($append_session = 0)
{
echo Util::formInput($append_session);
}
/**
* If magic_quotes_gpc is in use, run stripslashes() on $var.
*
* @access public
*
* @param string &$var The string to un-quote, if necessary.
*
* @return string $var, minus any magic quotes.
*/
function dispelMagicQuotes(&$var)
{
static $magic_quotes;
if (!isset($magic_quotes)) {
$magic_quotes = get_magic_quotes_gpc();
}
if ($magic_quotes) {
if (!is_array($var)) {
$var = stripslashes($var);
} else {
array_walk($var, array('Util', 'dispelMagicQuotes'));
}
}
return $var;
}
/**
* Get a form variable from GET or POST data, stripped of magic quotes if
* necessary. If the variable is somehow set in both the GET data and the
* POST data, the value from the POST data will be returned and the GET
* value will be ignored.
*
* @access public
*
* @param string $var The name of the form variable to look
* for.
* @param optional string $default The value to return if the variable is
* not there.
*
* @return string The cleaned form variable, or $default.
*/
function getFormData($var, $default = null)
{
return (($val = Util::getPost($var)) !== null)
? $val : Util::getGet($var, $default);
}
/**
* Get a form variable from GET data, stripped of magic quotes if necessary.
* This function will NOT return a POST variable.
*
* @access public
*
* @param string $var The name of the form variable to look
* for.
* @param optional string $default The value to return if the variable is
* not there.
*
* @return string The cleaned form variable, or $default.
*
* @since Horde 2.2
*/
function getGet($var, $default = null)
{
return (isset($_GET[$var]))
? Util::dispelMagicQuotes($_GET[$var])
: $default;
}
/**
* Get a form variable from POST data, stripped of magic quotes if
* necessary. This function will NOT return a GET variable.
*
* @access public
*
* @param string $var The name of the form variable to look
* for.
* @param optional string $default The value to return if the variable is
* not there.
*
* @return string The cleaned form variable, or $default.
*
* @since Horde 2.2
*/
function getPost($var, $default = null)
{
return (isset($_POST[$var]))
? Util::dispelMagicQuotes($_POST[$var])
: $default;
}
/**
* Determine the location of the system temporary directory. If a specific
* setting cannot be found, it defaults to /tmp.
*
* @access public
*
* @return string A directory name which can be used for temp files.
* Returns false if one could not be found.
*/
function getTempDir()
{
$tmp_locations = array('/tmp', '/var/tmp', 'c:\WUTemp', 'c:\temp', 'c:\windows\temp', 'c:\winnt\temp');
/* First, try PHP's upload_tmp_dir directive. */
if (empty($tmp)) {
$tmp = ini_get('upload_tmp_dir');
}
/* Otherwise, try to determine the TMPDIR environment
variable. */
if (empty($tmp)) {
$tmp = getenv('TMPDIR');
}
/* If we still cannot determine a value, then cycle through a
* list of preset possibilities. */
while (empty($tmp) && count($tmp_locations)) {
$tmp_check = array_shift($tmp_locations);
if (@is_dir($tmp_check)) {
$tmp = $tmp_check;
}
}
/* If it is still empty, we have failed, so return false;
* otherwise return the directory determined. */
return empty($tmp) ? false : $tmp;
}
/**
* Create a temporary filename for the lifetime of the script, and
* (optionally) register it to be deleted at request shutdown.
*
* @param optional string $prefix Prefix to make the temporary name more
* recognizable.
* @param optional boolean $delete Delete the file at the end of the
* request?
* @param optional string $dir Directory to create the temporary file
* in.
* @param optional boolean $secure If deleting file, should we securely
* delete the file?
*
* @return string Returns the full path-name to the temporary file.
* Returns false if a temp file could not be created.
*/
function getTempFile($prefix = '', $delete = true, $dir = '', $secure = false)
{
if (empty($dir) || !is_dir($dir)) {
$tmp_dir = Util::getTempDir();
} else {
$tmp_dir = $dir;
}
if (empty($tmp_dir)) {
return false;
}
$tmp_file = tempnam($tmp_dir, $prefix);
/* If the file was created, then register it for deletion and return */
if (empty($tmp_file)) {
return false;
} else {
if ($delete) {
Util::deleteAtShutdown($tmp_file, true, $secure);
}
return $tmp_file;
}
}
/**
* Create a temporary directory in the system's temporary directory.
*
* @access public
*
* @param optional boolean $delete Delete the temporary directory at the
* end of the request?
* @param optional string $temp_dir Use this temporary directory as the
* directory where the temporary
* directory will be created.
*
* @return string The pathname to the new temporary directory.
* Returns false if directory not created.
*/
function createTempDir($delete = true, $temp_dir = null)
{
if (is_null($temp_dir)) {
$temp_dir = Util::getTempDir();
}
if (empty($temp_dir)) {
return false;
}
/* Get the first 8 characters of a random string to use as a temporary
directory name. */
do {
$temp_dir .= '/' . substr(base_convert(mt_rand() . microtime(), 10, 36), 0, 8);
} while (file_exists($temp_dir));
$old_umask = umask(0000);
if (!mkdir($temp_dir, 0700)) {
$temp_dir = false;
} elseif ($delete) {
Util::deleteAtShutdown($temp_dir);
}
umask($old_umask);
return $temp_dir;
}
/**
* Removes given elements at request shutdown.
*
* If called with a filename will delete that file at request shutdown; if
* called with a directory will remove that directory and all files in that
* directory at request shutdown.
*
* If called with no arguments, return all elements to be deleted (this
* should only be done by Util::_deleteAtShutdown).
*
* The first time it is called, it initializes the array and registers
* Util::_deleteAtShutdown() as a shutdown function - no need to do so
* manually.
*
* The second parameter allows the unregistering of previously registered
* elements.
*
* @access public
*
* @param optional string $filename The filename to be deleted at the end
* of the request.
* @param optional boolean $register If true, then register the element for
* deletion, otherwise, unregister it.
* @param optional boolean $secure If deleting file, should we securely
* delete the file?
*/
function deleteAtShutdown($filename = false, $register = true,
$secure = false)
{
static $dirs, $files, $securedel;
/* Initialization of variables and shutdown functions. */
if (is_null($dirs)){
$dirs = array();
$files = array();
$securedel = array();
register_shutdown_function(array('Util', '_deleteAtShutdown'));
}
if ($filename) {
if ($register) {
if (@is_dir($filename)) {
$dirs[$filename] = true;
} else {
$files[$filename] = true;
}
if ($secure) {
$securedel[$filename] = true;
}
} else {
unset($dirs[$filename]);
unset($files[$filename]);
unset($securedel[$filename]);
}
} else {
return array($dirs, $files, $securedel);
}
}
/**
* Delete registered files at request shutdown.
*
* This function should never be called manually; it is registered as a
* shutdown function by Util::deleteAtShutdown() and called automatically
* at the end of the request. It will retrieve the list of folders and files
* to delete from Util::deleteAtShutdown()'s static array, and then iterate
* through, deleting folders recursively.
*
* Contains code from gpg_functions.php.
* Copyright (c) 2002-2003 Braverock Ventures
*
* @access private
*/
function _deleteAtShutdown()
{
$registered = Util::deleteAtShutdown();
$dirs = $registered[0];
$files = $registered[1];
$secure = $registered[2];
foreach ($files as $file => $val) {
/* Delete files */
if ($val && @file_exists($file)) {
/* Should we securely delete the file by overwriting the
data with a random string? */
if (isset($secure[$file])) {
$random_str = '';
for ($i = 0; $i < filesize($file); $i++) {
$random_str .= chr(mt_rand(0, 255));
}
$fp = fopen($file, 'r+');
fwrite($fp, $random_str);
fclose($fp);
}
@unlink($file);
}
}
foreach ($dirs as $dir => $val) {
/* Delete directories */
if ($val && @file_exists($dir)) {
/* Make sure directory is empty. */
$dir_class = dir($dir);
while (false !== ($entry = $dir_class->read())) {
if ($entry != '.' && $entry != '..') {
@unlink($dir . '/' . $entry);
}
}
$dir_class->close();
@rmdir($dir);
}
}
}
/**
* Output javascript code to close the current window.
*
* @access public
*
* @param string $code Any addtional javascript code to run before
* closing the window.
*/
function closeWindowJS($code = null)
{
echo '<script language="JavaScript" type="text/javascript">' . $code . 'window.close();</script>';
}
/**
* Caches the result of extension_loaded() calls.
*
* @access private
*
* @param string $ext The extension name.
*
* @return boolean Is the extension loaded?
*/
function extensionExists($ext)
{
static $cache = array();
if (!isset($cache[$ext])) {
$cache[$ext] = extension_loaded($ext);
}
return $cache[$ext];
}
/**
* Try to load a PHP extension, behaving correctly for all
* operating systems.
*
* @param string $ext The extension to load.
*
* @return boolean True if the extension is now loaded, false if not.
* True can mean that the extension was already loaded,
* OR was loaded dynamically.
*/
function loadExtension($ext)
{
/* If $ext is already loaded, our work is done. */
if (Util::extensionExists($ext)) {
return true;
}
/* See if we can call dl() at all, by the current ini
* settings. */
if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {
return false;
}
if (substr(PHP_OS, 0, 3) == 'WIN') {
$suffix = 'dll';
} else {
switch (PHP_OS) {
case 'HP-UX':
$suffix = 'sl';
break;
case 'AIX':
$suffix = 'a';
break;
case 'OSX':
$suffix = 'bundle';
break;
default:
$suffix = 'so';
}
}
return @dl($ext . '.' . $suffix) || @dl('php_' . $ext . '.' . $suffix);
}
/**
* Checks if all necessary parameters for a driver's configuration
* are set and returns a PEAR_Error if something is missing.
*
* @param array $params The configuration array with all parameters.
* @param array $fields An array with mandatory parameter names for
* this driver.
* @param string $name The clear text name of the driver. If
* not specified, the application name will be used.
* @param array $info (optional) A hash containing detailed information
* about the driver. Will be passed as the userInfo
* to the PEAR_Error.
*/
function assertDriverConfig($params, $fields, $name, $info = array())
{
$info = array_merge($info,
array('params' => $params,
'fields' => $fields,
'name' => $name));
if (!is_array($params) || !count($params)) {
return PEAR::throwError(sprintf(_("No configuration information specified for %s."), $name),
HORDE_ERROR_DRIVER_CONFIG_MISSING,
$info);
}
foreach ($fields as $field) {
if (!isset($params[$field])) {
return PEAR::throwError(sprintf(_("Required '%s' not specified in configuration."), $field, $name),
HORDE_ERROR_DRIVER_CONFIG,
$info);
}
}
}
/**
* Returns a format string to be used by strftime().
*
* @param string $format A format string as used by date().
*
* @return string A format string as similar as possible to $format.
*/
function date2strftime($format)
{
$dateSymbols = array('a', 'A', 'd', 'D', 'F', 'g', 'G', 'h', 'H', 'i', 'j', 'l', 'm', 'M', 'n', 'r', 's', 'T', 'w', 'W', 'y', 'Y', 'z', 'm/d/Y', 'M', "\n", 'g:i a', 'G:i', "\t", 'H:i:s', '%');
$strftimeSymbols = array('%p', '%p', '%d', '%a', '%B', '%I', '%H', '%I', '%H', '%M', '%e', '%A', '%m', '%b', '%m', '%a, %e %b %Y %T %Z', '%S', '%Z', '%w', '%V', '%y', '%Y', '%j', '%D', '%h', '%n', '%r', '%R', '%t', '%T', '%%');
return str_replace($dateSymbols, $strftimeSymbols, $format);
}
/**
* Returns a format string to be used by date().
*
* @param string $format A format string as used by strftime().
*
* @return string A format string as similar as possible to $format.
*/
function strftime2date($format)
{
$dateSymbols = array('a', 'A', 'd', 'D', 'F', 'g', 'G', 'h', 'H', 'i', 'j', 'l', 'm', 'M', 'n', 'r', 's', 'T', 'w', 'W', 'y', 'Y', 'z', 'm/d/Y', 'M', "\n", 'g:i a', 'G:i', "\t", 'H:i:s', '%');
$strftimeSymbols = array('%p', '%p', '%d', '%a', '%B', '%I', '%H', '%I', '%H', '%M', '%e', '%A', '%m', '%b', '%m', '%a, %e %b %Y %T %Z', '%S', '%Z', '%w', '%V', '%y', '%Y', '%j', '%D', '%h', '%n', '%r', '%R', '%t', '%T', '%%');
return str_replace($strftimeSymbols, $dateSymbols, $format);
}
}
if (!function_exists('_')) {
function _($string)
{
return $string;
}
function bindtextdomain()
{
}
function textdomain()
{
}
}
--- NEW FILE: Variables.php ---
<?php
/**
* Variables:: class.
*
* $Horde: framework/Util/Variables.php,v 1.4 2004/04/07 14:43:14 chuck Exp $
*
* @author Robert E. Coyle <robertecoyle at hotmail.com>
* @author Chuck Hagenbuch <chuck at horde.org>
* @package Horde_Util
*/
class Variables {
var $_vars;
var $_expectedVariables = array();
function Variables($vars = array())
{
if (is_null($vars)) {
require_once dirname(__FILE__) . '/../Util.php';
$vars = Util::dispelMagicQuotes($_REQUEST);
}
if (isset($vars['_formvars'])) {
$this->_expectedVariables = @unserialize($vars['_formvars']);
unset($vars['_formvars']);
}
$this->_vars = $vars;
}
function &getDefaultVariables()
{
require_once dirname(__FILE__) . '/Util.php';
return $ret = &new Variables(Util::dispelMagicQuotes($_REQUEST));
}
function exists($varname)
{
if (count($this->_expectedVariables) &&
$this->_exists($this->_expectedVariables, $varname, false)) {
return true;
}
return $this->_exists($this->_vars, $varname, false);
}
function get($varname)
{
$this->_getExists($this->_vars, $varname, $value);
return $value;
}
function getExists($varname, &$exists)
{
$exists = $this->_getExists($this->_vars, $varname, $value);
return $value;
}
function set($varname, $value)
{
$this->_vars[$varname] = $value;
}
function add($varname, $value)
{
if ($this->exists($varname)) {
return false;
}
$this->_vars[$varname] = $value;
}
function remove($varname)
{
require_once 'Horde/Array.php';
Horde_Array::getArrayParts($varname, $base, $keys);
if (!is_null($base)) {
eval("unset(\$this->_vars['" . $base . "']['" . join("']['", $keys) . "']);");
} else {
unset($this->_vars[$varname]);
}
}
/**
* Find out whether or not $varname was set in $array.
*
* @access private
*
* @param array $array The array to search in (usually
* either $this->_vars or
* $this->_expectedVariables).
* @param string $varname The name of the variable to look for.
* @param optional boolean $checkExpectedVariables If we don't find $varname, should we
* check $this->_expectedVariables to see if it
* should have existed (like a checkbox
* or select multiple).
*
* @return Whether or not the variable was set (or, if we've checked
* $this->_expectedVariables, should have been set).
*/
function _exists($array, $varname, $checkExpectedVariables = true)
{
return $this->_getExists($array, $varname, $value, $checkExpectedVariables);
}
/**
* Fetch the requested variable ($varname) into $value, and return whether
* or not the variable was set in $array.
*
* @access private
*
* @param array $array The array to search in (usually
* either $this->_vars or
* $this->_expectedVariables).
* @param string $varname The name of the variable to look for.
* @param mixed &$value $varname's value gets assigned to
* this variable.
* @param optional bool $checkExpectedVariables If we don't find $varname, should we
* check $this->_expectedVariables to see if it
* should have existed (like a checkbox
* or select multiple).
*
* @return Whether or not the variable was set (or, if we've checked
* $this->_expectedVariables, should have been set).
*/
function _getExists($array, $varname, &$value, $checkExpectedVariables = true)
{
require_once 'Horde/Array.php';
if (Horde_Array::getArrayParts($varname, $base, $keys)) {
if (!isset($array[$base])) {
$value = null;
// If we're supposed to check $this->_expectedVariables, do so,
// but make sure not to check it again.
return $checkExpectedVariables ? $this->_exists($this->_expectedVariables, $varname, false) : false;
} else {
$searchspace = &$array[$base];
while (count($keys)) {
$key = array_shift($keys);
if (!isset($searchspace[$key])) {
$value = null;
// If we're supposed to check $this->_expectedVariables,
// do so, but make sure not to check it again.
return $checkExpectedVariables ? $this->_exists($this->_expectedVariables, $varname, false) : false;
}
$searchspace = &$searchspace[$key];
}
$value = $searchspace;
return true;
}
} else {
$value = isset($array[$varname]) ? $array[$varname] : null;
if (!is_null($value)) {
return true;
} elseif ($checkExpectedVariables) {
// If we're supposed to check $this->_expectedVariables, do so,
// but make sure not to check it again.
return $this->_exists($this->_expectedVariables, $varname, false);
} else {
return false;
}
}
}
}
--- NEW FILE: package.xml ---
<?xml version="1.0" encoding="ISO-8859-1"?>
<!-- $Horde: framework/Util/package.xml,v 1.4 2004/02/24 01:11:57 chuck Exp $ -->
<!DOCTYPE package SYSTEM "http://pear.php.net/dtd/package-1.1">
<package version="1.0">
<name>Horde_Util</name>
<summary>Horde Utility Libraries</summary>
<description>
These classes provide functionality useful for all kind of applications.
</description>
<license>LGPL</license>
<maintainers>
<maintainer>
<user>chuck</user>
<role>lead</role>
<name>Chuck Hagenbuch</name>
<email>chuck at horde.org</email>
</maintainer>
<maintainer>
<user>jon</user>
<role>lead</role>
<name>Jon Parise</name>
<email>jon at horde.org</email>
</maintainer>
<maintainer>
<user>jan</user>
<role>lead</role>
<name>Jan Schneider</name>
<email>jan at horde.org</email>
</maintainer>
</maintainers>
<release>
<version>0.0.1</version>
<state>alpha</state>
<date>2003-10-28</date>
<notes>Initial release as a PEAR package</notes>
<filelist>
<file role="php" baseinstalldir="/Horde" name="Array.php"/>
<file role="php" baseinstalldir="/Horde" name="String.php"/>
<file role="php" baseinstalldir="/Horde" name="Util.php"/>
<file role="php" baseinstalldir="/Horde" name="Variables.php"/>
<dir name="tests" role="test">
<file name="String.phpt"/>
<file name="String2.phpt"/>
<file name="utf-8.phpt"/>
</dir>
</filelist>
<provides type="class" name="Horde_Array"/>
<provides type="class" name="String"/>
<provides type="class" name="Util"/>
<provides type="class" name="Variables"/>
</release>
<changelog>
<release>
<version>0.0.1</version>
<state>alpha</state>
<date>2003-10-28</date>
<notes>Initial release as a PEAR package</notes>
</release>
</changelog>
</package>
- Previous message: steffen: server/kolab-horde-framework/kolab-horde-framework/UI/UI Language.php, NONE, 1.1 Pager.php, NONE, 1.1 Table.php, NONE, 1.1 Tabs.php, NONE, 1.1 VarRenderer.php, NONE, 1.1 Widget.php, NONE, 1.1
- Next message: steffen: server/kolab-horde-framework/kolab-horde-framework/Util/tests String.phpt, NONE, 1.1 String2.phpt, NONE, 1.1 utf-8.phpt, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the commits
mailing list