Horde 3.1.3 : /lib/Horde/Serialize.php source

[Sommaire] [Imprimer]
   1  <?php
   2  
   3  define('SERIALIZE_UNKNOWN', -1);
   4  define('SERIALIZE_NONE', 0);
   5  define('SERIALIZE_WDDX', 1);
   6  define('SERIALIZE_BZIP', 2);
   7  define('SERIALIZE_IMAP8', 3);
   8  define('SERIALIZE_IMAPUTF7', 4);
   9  define('SERIALIZE_IMAPUTF8', 5);
  10  define('SERIALIZE_BASIC', 6);
  11  define('SERIALIZE_GZ_DEFLATE', 7);
  12  define('SERIALIZE_GZ_COMPRESS', 8);
  13  define('SERIALIZE_GZ_ENCOD', 9);
  14  define('SERIALIZE_BASE64', 10);
  15  define('SERIALIZE_SQLXML', 11);
  16  define('SERIALIZE_RAW', 12);
  17  define('SERIALIZE_URL', 13);
  18  define('SERIALIZE_UTF7', 14);
  19  
  20  /** Use SERIALIZE_UTF7 and SERIALIZE_BASIC stacked.  */
  21  define('SERIALIZE_UTF7_BASIC', 15);
  22  
  23  
  24  /**
  25   * The Serialize:: class provides various methods of encapsulating data.
  26   *
  27   * $Horde: framework/Serialize/Serialize.php,v 1.25.10.9 2006/01/01 21:28:34 jan Exp $
  28   *
  29   * Copyright 2001-2006 Stephane Huther <shuther@bigfoot.com>
  30   *
  31   * See the enclosed file COPYING for license information (LGPL).  If you
  32   * did not receive this file, see http://www.fsf.org/copyleft/lgpl.html.
  33   *
  34   * @author  Stephane Huther <shuther@bigfoot.com>
  35   * @since   Horde 2.0
  36   * @package Horde_Serialize
  37   */
  38  class Horde_Serialize {
  39  
  40      /**
  41       * Serialize a value.
  42       *
  43       * See the list of constants at the top of the file for the serializing
  44       * techniques that can be used.
  45       *
  46       * @param mixed $data    The data to be serialized.
  47       * @param mixed $mode    The mode of serialization. Can be either a single
  48       *                       mode or array of modes.  If array, will be
  49       *                       serialized in the order provided.
  50       * @param mixed $params  Any additional parameters the serialization method
  51       *                       requires.
  52       *
  53       * @return string  The serialized data.
  54       *                 Returns PEAR_Error on error.
  55       */
  56      function serialize($data, $mode = array(SERIALIZE_BASIC), $params = null)
  57      {
  58          if (!is_array($mode)) {
  59              $mode = array($mode);
  60          }
  61  
  62          /* Return now if no data. */
  63          if (empty($data) && !is_array($data)) {
  64              return $data;
  65          }
  66  
  67          /* Parse through the list of serializing modes. */
  68          foreach ($mode as $val) {
  69              /* Check to make sure the mode is supported. */
  70              if (!Horde_Serialize::hasCapability($val)) {
  71                  return PEAR::raiseError('Unsupported serialization type');
  72              }
  73              Horde_Serialize::_serialize($data, $val, $params);
  74              if (is_a($data, 'PEAR_Error')) {
  75                  break;
  76              }
  77          }
  78  
  79          return $data;
  80      }
  81  
  82      /**
  83       * Serialize data.
  84       *
  85       * @access private
  86       *
  87       * @param mixed &$data            The data to be serialized.
  88       * @param mixed $mode             The mode of serialization. Can be
  89       *                                either a single mode or array of modes.
  90       *                                If array, will be serialized in the
  91       *                                order provided.
  92       * @param mixed $params  Any additional parameters the serialization method
  93       *                       requires.
  94       */
  95      function _serialize(&$data, $mode, $params = null)
  96      {
  97          switch ($mode) {
  98          case SERIALIZE_NONE:
  99              break;
 100  
 101          case SERIALIZE_BZIP:
 102              $data = bzcompress($data, 9, 30);
 103              break;
 104  
 105          case SERIALIZE_WDDX:
 106              $data = wddx_serialize_value($data);
 107              break;
 108  
 109          case SERIALIZE_IMAP8:
 110              $data = imap_8bit($data);
 111              break;
 112  
 113          case SERIALIZE_IMAPUTF7:
 114              $data = imap_utf7_encode($data);
 115              break;
 116  
 117          case SERIALIZE_IMAPUTF8:
 118              $data = imap_utf8($data);
 119              break;
 120  
 121          case SERIALIZE_GZ_DEFLATE:
 122              $data = gzdeflate($data, 9);
 123              break;
 124  
 125          case SERIALIZE_BASIC:
 126              $data = serialize($data);
 127              break;
 128  
 129          case SERIALIZE_GZ_COMPRESS:
 130              $data = gzcompress($data, 9);
 131              break;
 132  
 133          case SERIALIZE_BASE64:
 134              $data = base64_encode($data);
 135              break;
 136  
 137          case SERIALIZE_GZ_ENCOD:
 138              $data = gzencode($data, 9);
 139              break;
 140  
 141          case SERIALIZE_RAW:
 142              $data = rawurlencode($data);
 143              break;
 144  
 145          case SERIALIZE_URL:
 146              $data = urlencode($data);
 147              break;
 148  
 149          case SERIALIZE_SQLXML:
 150              require_once 'DB.php';
 151              $sql2xml = &new xml_sql2xml();
 152              $data = $sql2xml->getXML($data);
 153              break;
 154  
 155          case SERIALIZE_UTF7:
 156              require_once  'Horde/String.php';
 157              $data = String::convertCharset($data, $params, 'utf-7');
 158              break;
 159  
 160          case SERIALIZE_UTF7_BASIC:
 161              Horde_Serialize::_serialize($data, SERIALIZE_UTF7, $params);
 162              Horde_Serialize::_serialize($data, SERIALIZE_BASIC, $params);
 163              break;
 164          }
 165      }
 166  
 167      /**
 168       * Unserialize a value.
 169       *
 170       * See the list of constants at the top of the file for the serializing
 171       * techniques that can be used.
 172       *
 173       * @param mixed $data             The data to be unserialized.
 174       * @param mixed $mode    The mode of unserialization.  Can be either a
 175       *                       single mode or array of modes.  If array, will be
 176       *                       unserialized in the order provided.
 177       * @param mixed $params  Any additional parameters the unserialization
 178       *                       method requires.
 179       *
 180       * @return string  The unserialized data.
 181       *                 Returns PEAR_Error on error.
 182       */
 183      function unserialize($data, $mode = SERIALIZE_BASIC, $params = null)
 184      {
 185          if (!is_array($mode)) {
 186              $mode = array($mode);
 187          }
 188  
 189          /* Return now if no data. */
 190          if (empty($data)) {
 191              return $data;
 192          }
 193  
 194          /* Parse through the list of unserializing modes. */
 195          foreach ($mode as $val) {
 196              /* Check to make sure the mode is supported. */
 197              if (!Horde_Serialize::hasCapability($val)) {
 198                  return PEAR::raiseError('Unsupported unserialization type');
 199              }
 200              Horde_Serialize::_unserialize($data, $val, $params);
 201              if (is_a($data, 'PEAR_Error')) {
 202                  break;
 203              }
 204          }
 205  
 206          return $data;
 207      }
 208  
 209      /**
 210       * Unserialize data.
 211       *
 212       * @access private
 213       *
 214       * @param mixed &$data   The data to be unserialized.
 215       * @param mixed $mode    The mode of unserialization. Can be either a
 216       *                       single mode or array of modes.  If array, will be
 217       *                       unserialized in the order provided.
 218       * @param mixed $params  Any additional parameters the unserialization
 219       *                       method requires.
 220       */
 221      function _unserialize(&$data, $mode, $params = null)
 222      {
 223          switch ($mode) {
 224          case SERIALIZE_NONE:
 225          case SERIALIZE_SQLXML:
 226              break;
 227  
 228          case SERIALIZE_RAW:
 229              $data = rawurldecode($data);
 230              break;
 231  
 232          case SERIALIZE_URL:
 233              $data = urldecode($data);
 234              break;
 235  
 236          case SERIALIZE_WDDX:
 237              $data = wddx_deserialize($data);
 238              break;
 239  
 240          case SERIALIZE_BZIP:
 241              $data = bzdecompress($data, false);
 242              break;
 243  
 244          case SERIALIZE_IMAPUTF7:
 245              $data = imap_utf7_decode($data);
 246              break;
 247  
 248          case SERIALIZE_BASIC:
 249              $data = @unserialize($data);
 250              break;
 251  
 252          case SERIALIZE_GZ_DEFLATE:
 253              $data = gzinflate($data);
 254              break;
 255  
 256          case SERIALIZE_BASE64:
 257              $data = base64_decode($data);
 258              break;
 259  
 260          case SERIALIZE_GZ_COMPRESS:
 261              $data = gzuncompress($data);
 262              break;
 263  
 264          case SERIALIZE_UTF7:
 265              require_once  'Horde/String.php';
 266              $data = String::convertCharset($data, 'utf-7', $params);
 267              break;
 268  
 269          case SERIALIZE_UTF7_BASIC:
 270              Horde_Serialize::_unserialize($data, SERIALIZE_BASIC, $params);
 271              Horde_Serialize::_unserialize($data, SERIALIZE_UTF7, $params);
 272              break;
 273          }
 274      }
 275  
 276      /**
 277       * Check whether or not a serialization method is supported.
 278       *
 279       * @param integer $mode  The serialization method.
 280       *
 281       * @return boolean  True if supported, false if not.
 282       */
 283      function hasCapability($mode)
 284      {
 285          switch ($mode) {
 286          case SERIALIZE_BZIP:
 287              return Util::extensionExists('bz2');
 288  
 289          case SERIALIZE_WDDX:
 290              return Util::extensionExists('wddx');
 291  
 292          case SERIALIZE_IMAPUTF7:
 293          case SERIALIZE_IMAPUTF8:
 294          case SERIALIZE_IMAP8:
 295              return Util::extensionExists('imap');
 296  
 297          case SERIALIZE_GZ_DEFLATE:
 298          case SERIALIZE_GZ_COMPRESS:
 299          case SERIALIZE_GZ_ENCOD:
 300              return Util::extensionExists('zlib');
 301  
 302          case SERIALIZE_SQLXML:
 303              return @include_once 'XML/sql2xml.php';
 304  
 305          case SERIALIZE_NONE:
 306          case SERIALIZE_BASIC:
 307          case SERIALIZE_BASE64:
 308          case SERIALIZE_RAW:
 309          case SERIALIZE_URL:
 310          case SERIALIZE_UTF7:
 311          case SERIALIZE_UTF7_BASIC:
 312              return true;
 313  
 314          default:
 315              return false;
 316          }
 317      }
 318  
 319  }
Code source de Horde 3.1.3

/lib/Horde/ -> Serialize.php (source)
