Source for file Serializer.class.php

Documentation is available at Serializer.class.php

  1. <?php
  2. /**
  3. * XOAD Serializer file.
  4. *
  5. * <p>This file defines the {@link XOAD_Serializer} Class.</p>
  6. * <p>Example:</p>
  7. * <code>
  8. * <?php
  9. *
  10. * require_once('xoad.php');
  11. *
  12. * $arr = array(1, 2, "String", array("Nested", 3, 4, array(5, 6)));
  13. *
  14. * ?>
  15. * <script type="text/javascript">
  16. *
  17. * var arr = <?= XOAD_Serializer::serialize($arr) ?>;
  18. *
  19. * </script>
  20. * </code>
  21. *
  22. * @author Stanimir Angeloff
  23. *
  24. * @package XOAD
  25. *
  26. * @version 0.6.0.0
  27. *
  28. */
  29.  
  30. /**
  31. * XOAD Serializer Class.
  32. *
  33. * <p>This class is used to serialize a PHP variable
  34. * into a {@link http://www.json.org JSON} string.</p>
  35. * <p>Example:</p>
  36. * <code>
  37. * <?php
  38. *
  39. * require_once('xoad.php');
  40. *
  41. * $arr = array(1, 2, "String", array("Nested", 3, 4, array(5, 6)));
  42. *
  43. * ?>
  44. * <script type="text/javascript">
  45. *
  46. * var arr = <?= XOAD_Serializer::serialize($arr) ?>;
  47. *
  48. * </script>
  49. * </code>
  50. *
  51. * @author Stanimir Angeloff
  52. *
  53. * @package XOAD
  54. *
  55. * @version 0.6.0.0
  56. *
  57. */
  58. class XOAD_Serializer extends XOAD_Observable
  59. {
  60. /**
  61. * Serializes a PHP variable into a {@link http://www.json.org JSON} string.
  62. *
  63. * <p>Example:</p>
  64. * <code>
  65. * <script type="text/javascript">
  66. * <?php require_once('xoad.php'); ?>
  67. *
  68. * var arr = <?= XOAD_Serializer::serialize(array(1, 2, "string", array("Nested"))) ?>;
  69. *
  70. * alert(arr);
  71. *
  72. * </script>
  73. * </code>
  74. *
  75. * @access public
  76. *
  77. * @param mixed $var Variable to serialize.
  78. *
  79. * @return string {@link http://www.json.org JSON} string that
  80. * represents the variable.
  81. *
  82. * @static
  83. *
  84. */
  85. function serialize(&$var)
  86. {
  87. $type = XOAD_Utilities::getType($var);
  88.  
  89. if ($type == 'bool') {
  90.  
  91. if ($var) {
  92.  
  93. return "true";
  94.  
  95. } else {
  96.  
  97. return "false";
  98. }
  99.  
  100. } else if ($type == 'int') {
  101.  
  102. return sprintf('%d', $var);
  103.  
  104. } else if ($type == 'float') {
  105.  
  106. return sprintf('%f', $var);
  107.  
  108. } else if ($type == 'string') {
  109.  
  110. if (strlen($var) >= strlen(XOAD_SERIALIZER_SKIP_STRING)) {
  111.  
  112. if (strcasecmp(substr($var, 0, strlen(XOAD_SERIALIZER_SKIP_STRING)), XOAD_SERIALIZER_SKIP_STRING) == 0) {
  113.  
  114. return substr($var, strlen(XOAD_SERIALIZER_SKIP_STRING), strlen($var) - strlen(XOAD_SERIALIZER_SKIP_STRING));
  115. }
  116. }
  117.  
  118. // This code is based on morris_hirsch's
  119. // comment in utf8_decode function documentation.
  120. //
  121. // http://bg.php.net/utf8_decode
  122. //
  123. // Thank you.
  124. //
  125.  
  126. $ascii = '';
  127.  
  128. $length = strlen($var);
  129.  
  130. for ($iterator = 0; $iterator < $length; $iterator ++) {
  131.  
  132. $char = $var{$iterator};
  133.  
  134. $charCode = ord($char);
  135.  
  136. if ($charCode == 0x08) {
  137.  
  138. $ascii .= '\b';
  139.  
  140. } else if ($charCode == 0x09) {
  141.  
  142. $ascii .= '\t';
  143.  
  144. } else if ($charCode == 0x0A) {
  145.  
  146. $ascii .= '\n';
  147.  
  148. } else if ($charCode == 0x0C) {
  149.  
  150. $ascii .= '\f';
  151.  
  152. } else if ($charCode == 0x0D) {
  153.  
  154. $ascii .= '\r';
  155.  
  156. } else if (($charCode == 0x22) || ($charCode == 0x2F) || ($charCode == 0x5C)) {
  157.  
  158. $ascii .= '\\' . $var{$iterator};
  159.  
  160. } else if ($charCode < 128) {
  161.  
  162. $ascii .= $char;
  163.  
  164. } else if ($charCode >> 5 == 6) {
  165.  
  166. $byteOne = ($charCode & 31);
  167.  
  168. $iterator ++;
  169.  
  170. $char = $var{$iterator};
  171.  
  172. $charCode = ord($char);
  173.  
  174. $byteTwo = ($charCode & 63);
  175.  
  176. $charCode = ($byteOne * 64) + $byteTwo;
  177.  
  178. $ascii .= sprintf('\u%04s', dechex($charCode));
  179.  
  180. } else if ($charCode >> 4 == 14) {
  181.  
  182. $byteOne = ($charCode & 31);
  183.  
  184. $iterator ++;
  185.  
  186. $char = $var{$iterator};
  187.  
  188. $charCode = ord($char);
  189.  
  190. $byteTwo = ($charCode & 63);
  191.  
  192. $iterator ++;
  193.  
  194. $char = $var{$iterator};
  195.  
  196. $charCode = ord($char);
  197.  
  198. $byteThree = ($charCode & 63);
  199.  
  200. $charCode = ((($byteOne * 64) + $byteTwo) * 64) + $byteThree;
  201.  
  202. $ascii .= sprintf('\u%04s', dechex($charCode));
  203.  
  204. } else if ($charCode >> 3 == 30) {
  205.  
  206. $byteOne = ($charCode & 31);
  207.  
  208. $iterator ++;
  209.  
  210. $char = $var{$iterator};
  211.  
  212. $charCode = ord($char);
  213.  
  214. $byteTwo = ($charCode & 63);
  215.  
  216. $iterator ++;
  217.  
  218. $char = $var{$iterator};
  219.  
  220. $charCode = ord($char);
  221.  
  222. $byteThree = ($charCode & 63);
  223.  
  224. $iterator ++;
  225.  
  226. $char = $var{$iterator};
  227.  
  228. $charCode = ord($char);
  229.  
  230. $byteFour = ($charCode & 63);
  231.  
  232. $charCode = ((((($byteOne * 64) + $byteTwo) * 64) + $byteThree) * 64) + $byteFour;
  233.  
  234. $ascii .= sprintf('\u%04s', dechex($charCode));
  235. }
  236. }
  237.  
  238. return ('"' . $ascii . '"');
  239.  
  240. } else if ($type == 's_array') {
  241.  
  242. $index = 0;
  243.  
  244. $length = sizeof($var);
  245.  
  246. $returnValue = '[';
  247.  
  248. foreach ($var as $value) {
  249.  
  250. $returnValue .= XOAD_Serializer::serialize($value);
  251.  
  252. if ($index < $length - 1) {
  253.  
  254. $returnValue .= ',';
  255. }
  256.  
  257. $index ++;
  258. }
  259.  
  260. $returnValue .= ']';
  261.  
  262. return $returnValue;
  263.  
  264. } else if ($type == 'a_array') {
  265.  
  266. $index = 0;
  267.  
  268. $length = sizeof($var);
  269.  
  270. $returnValue = '{';
  271.  
  272. foreach ($var as $key => $value) {
  273.  
  274. $returnValue .= XOAD_Serializer::serialize($key);
  275.  
  276. $returnValue .= ':';
  277.  
  278. $returnValue .= XOAD_Serializer::serialize($value);
  279.  
  280. if ($index < $length - 1) {
  281.  
  282. $returnValue .= ',';
  283. }
  284.  
  285. $index ++;
  286. }
  287.  
  288. $returnValue .= '}';
  289.  
  290. return $returnValue;
  291.  
  292. } else if ($type == 'object') {
  293.  
  294. $objectVars = get_object_vars($var);
  295.  
  296. return XOAD_Serializer::serialize($objectVars);
  297. }
  298.  
  299. return "null";
  300. }
  301.  
  302. /**
  303. * Adds a {@link XOAD_Serializer} events observer.
  304. *
  305. * @access public
  306. *
  307. * @param mixed $observer The observer object to add (must extend {@link XOAD_Observer}).
  308. *
  309. * @return string true on success, false otherwise.
  310. *
  311. * @static
  312. *
  313. */
  314. function addObserver(&$observer)
  315. {
  316. return parent::addObserver($observer, 'XOAD_Serializer');
  317. }
  318.  
  319. /**
  320. *
  321. * @access public
  322. *
  323. * @return bool
  324. *
  325. */
  326. function notifyObservers($event = 'default', $arg = null)
  327. {
  328. return parent::notifyObservers($event, $arg, 'XOAD_Serializer');
  329. }
  330. }
  331. ?>

Documentation generated on Sat, 12 Nov 2005 20:24:35 +0200 by phpDocumentor 1.3.0RC3