diff -r 5b37998e522e -r 162c1de6545a web/lib/Zend/Amf/Parse/Amf3/Serializer.php --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/Zend/Amf/Parse/Amf3/Serializer.php Fri Mar 11 15:05:35 2011 +0100 @@ -0,0 +1,529 @@ +_stream->writeByte($markerType); + + switch ($markerType) { + case Zend_Amf_Constants::AMF3_NULL: + break; + case Zend_Amf_Constants::AMF3_BOOLEAN_FALSE: + break; + case Zend_Amf_Constants::AMF3_BOOLEAN_TRUE: + break; + case Zend_Amf_Constants::AMF3_INTEGER: + $this->writeInteger($data); + break; + case Zend_Amf_Constants::AMF3_NUMBER: + $this->_stream->writeDouble($data); + break; + case Zend_Amf_Constants::AMF3_STRING: + $this->writeString($data); + break; + case Zend_Amf_Constants::AMF3_DATE: + $this->writeDate($data); + break; + case Zend_Amf_Constants::AMF3_ARRAY: + $this->writeArray($data); + break; + case Zend_Amf_Constants::AMF3_OBJECT: + $this->writeObject($data); + break; + case Zend_Amf_Constants::AMF3_BYTEARRAY: + $this->writeByteArray($data); + break; + case Zend_Amf_Constants::AMF3_XMLSTRING; + $this->writeXml($data); + break; + default: + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Unknown Type Marker: ' . $markerType); + } + } else { + // Detect Type Marker + if (is_resource($data)) { + $data = Zend_Amf_Parse_TypeLoader::handleResource($data); + } + switch (true) { + case (null === $data): + $markerType = Zend_Amf_Constants::AMF3_NULL; + break; + case (is_bool($data)): + if ($data){ + $markerType = Zend_Amf_Constants::AMF3_BOOLEAN_TRUE; + } else { + $markerType = Zend_Amf_Constants::AMF3_BOOLEAN_FALSE; + } + break; + case (is_int($data)): + if (($data > 0xFFFFFFF) || ($data < -268435456)) { + $markerType = Zend_Amf_Constants::AMF3_NUMBER; + } else { + $markerType = Zend_Amf_Constants::AMF3_INTEGER; + } + break; + case (is_float($data)): + $markerType = Zend_Amf_Constants::AMF3_NUMBER; + break; + case (is_string($data)): + $markerType = Zend_Amf_Constants::AMF3_STRING; + break; + case (is_array($data)): + $markerType = Zend_Amf_Constants::AMF3_ARRAY; + break; + case (is_object($data)): + // Handle object types. + if (($data instanceof DateTime) || ($data instanceof Zend_Date)) { + $markerType = Zend_Amf_Constants::AMF3_DATE; + } else if ($data instanceof Zend_Amf_Value_ByteArray) { + $markerType = Zend_Amf_Constants::AMF3_BYTEARRAY; + } else if (($data instanceof DOMDocument) || ($data instanceof SimpleXMLElement)) { + $markerType = Zend_Amf_Constants::AMF3_XMLSTRING; + } else { + $markerType = Zend_Amf_Constants::AMF3_OBJECT; + } + break; + default: + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Unsupported data type: ' . gettype($data)); + } + $this->writeTypeMarker($data, $markerType); + } + } + + /** + * Write an AMF3 integer + * + * @param int|float $data + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeInteger($int) + { + if (($int & 0xffffff80) == 0) { + $this->_stream->writeByte($int & 0x7f); + return $this; + } + + if (($int & 0xffffc000) == 0 ) { + $this->_stream->writeByte(($int >> 7 ) | 0x80); + $this->_stream->writeByte($int & 0x7f); + return $this; + } + + if (($int & 0xffe00000) == 0) { + $this->_stream->writeByte(($int >> 14 ) | 0x80); + $this->_stream->writeByte(($int >> 7 ) | 0x80); + $this->_stream->writeByte($int & 0x7f); + return $this; + } + + $this->_stream->writeByte(($int >> 22 ) | 0x80); + $this->_stream->writeByte(($int >> 15 ) | 0x80); + $this->_stream->writeByte(($int >> 8 ) | 0x80); + $this->_stream->writeByte($int & 0xff); + return $this; + } + + /** + * Send string to output stream, without trying to reference it. + * The string is prepended with strlen($string) << 1 | 0x01 + * + * @param string $string + * @return Zend_Amf_Parse_Amf3_Serializer + */ + protected function writeBinaryString(&$string){ + $ref = strlen($string) << 1 | 0x01; + $this->writeInteger($ref); + $this->_stream->writeBytes($string); + + return $this; + } + + /** + * Send string to output stream + * + * @param string $string + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeString(&$string) + { + $len = strlen($string); + if(!$len){ + $this->writeInteger(0x01); + return $this; + } + + $ref = array_search($string, $this->_referenceStrings, true); + if($ref === false){ + $this->_referenceStrings[] = $string; + $this->writeBinaryString($string); + } else { + $ref <<= 1; + $this->writeInteger($ref); + } + + return $this; + } + + /** + * Send ByteArray to output stream + * + * @param string|Zend_Amf_Value_ByteArray $data + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeByteArray(&$data) + { + if ($this->writeObjectReference($data)) { + return $this; + } + + if (is_string($data)) { + //nothing to do + } else if ($data instanceof Zend_Amf_Value_ByteArray) { + $data = $data->getData(); + } else { + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Invalid ByteArray specified; must be a string or Zend_Amf_Value_ByteArray'); + } + + $this->writeBinaryString($data); + + return $this; + } + + /** + * Send xml to output stream + * + * @param DOMDocument|SimpleXMLElement $xml + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeXml($xml) + { + if ($this->writeObjectReference($xml)) { + return $this; + } + + if(is_string($xml)) { + //nothing to do + } else if ($xml instanceof DOMDocument) { + $xml = $xml->saveXml(); + } else if ($xml instanceof SimpleXMLElement) { + $xml = $xml->asXML(); + } else { + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Invalid xml specified; must be a DOMDocument or SimpleXMLElement'); + } + + $this->writeBinaryString($xml); + + return $this; + } + + /** + * Convert DateTime/Zend_Date to AMF date + * + * @param DateTime|Zend_Date $date + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeDate($date) + { + if ($this->writeObjectReference($date)) { + return $this; + } + + if ($date instanceof DateTime) { + $dateString = $date->format('U') * 1000; + } elseif ($date instanceof Zend_Date) { + $dateString = $date->toString('U') * 1000; + } else { + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Invalid date specified; must be a string DateTime or Zend_Date object'); + } + + $this->writeInteger(0x01); + // write time to stream minus milliseconds + $this->_stream->writeDouble($dateString); + return $this; + } + + /** + * Write a PHP array back to the amf output stream + * + * @param array $array + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeArray(&$array) + { + // arrays aren't reference here but still counted + $this->_referenceObjects[] = $array; + + // have to seperate mixed from numberic keys. + $numeric = array(); + $string = array(); + foreach ($array as $key => &$value) { + if (is_int($key)) { + $numeric[] = $value; + } else { + $string[$key] = $value; + } + } + + // write the preamble id of the array + $length = count($numeric); + $id = ($length << 1) | 0x01; + $this->writeInteger($id); + + //Write the mixed type array to the output stream + foreach($string as $key => &$value) { + $this->writeString($key) + ->writeTypeMarker($value); + } + $this->writeString($this->_strEmpty); + + // Write the numeric array to ouput stream + foreach($numeric as &$value) { + $this->writeTypeMarker($value); + } + return $this; + } + + /** + * Check if the given object is in the reference table, write the reference if it exists, + * otherwise add the object to the reference table + * + * @param mixed $object object reference to check for reference + * @param mixed $objectByVal object to check for reference + * @return Boolean true, if the reference was written, false otherwise + */ + protected function writeObjectReference(&$object, $objectByVal = false) + { + // Workaround for PHP5 with E_STRICT enabled complaining about "Only + // variables should be passed by reference" + if ((null === $object) && ($objectByVal !== false)) { + $object = &$objectByVal; + } + + $ref = array_search($object, $this->_referenceObjects,true); + + // quickly handle object references + if ($ref !== false){ + $ref <<= 1; + $this->writeInteger($ref); + return true; + } + $this->_referenceObjects[] = $object; + return false; + } + + /** + * Write object to ouput stream + * + * @param mixed $data + * @return Zend_Amf_Parse_Amf3_Serializer + */ + public function writeObject($object) + { + if($this->writeObjectReference($object)){ + return $this; + } + + $className = ''; + + //Check to see if the object is a typed object and we need to change + switch (true) { + // the return class mapped name back to actionscript class name. + case ($className = Zend_Amf_Parse_TypeLoader::getMappedClassName(get_class($object))): + break; + + // Check to see if the user has defined an explicit Action Script type. + case isset($object->_explicitType): + $className = $object->_explicitType; + break; + + // Check if user has defined a method for accessing the Action Script type + case method_exists($object, 'getASClassName'): + $className = $object->getASClassName(); + break; + + // No return class name is set make it a generic object + case ($object instanceof stdClass): + $className = ''; + break; + + // By default, use object's class name + default: + $className = get_class($object); + break; + } + + $writeTraits = true; + + //check to see, if we have a corresponding definition + if(array_key_exists($className, $this->_referenceDefinitions)){ + $traitsInfo = $this->_referenceDefinitions[$className]['id']; + $encoding = $this->_referenceDefinitions[$className]['encoding']; + $propertyNames = $this->_referenceDefinitions[$className]['propertyNames']; + + $traitsInfo = ($traitsInfo << 2) | 0x01; + + $writeTraits = false; + } else { + $propertyNames = array(); + + if($className == ''){ + //if there is no className, we interpret the class as dynamic without any sealed members + $encoding = Zend_Amf_Constants::ET_DYNAMIC; + } else { + $encoding = Zend_Amf_Constants::ET_PROPLIST; + + foreach($object as $key => $value) { + if( $key[0] != "_") { + $propertyNames[] = $key; + } + } + } + + $this->_referenceDefinitions[$className] = array( + 'id' => count($this->_referenceDefinitions), + 'encoding' => $encoding, + 'propertyNames' => $propertyNames, + ); + + $traitsInfo = Zend_Amf_Constants::AMF3_OBJECT_ENCODING; + $traitsInfo |= $encoding << 2; + $traitsInfo |= (count($propertyNames) << 4); + } + + $this->writeInteger($traitsInfo); + + if($writeTraits){ + $this->writeString($className); + foreach ($propertyNames as $value) { + $this->writeString($value); + } + } + + try { + switch($encoding) { + case Zend_Amf_Constants::ET_PROPLIST: + //Write the sealed values to the output stream. + foreach ($propertyNames as $key) { + $this->writeTypeMarker($object->$key); + } + break; + case Zend_Amf_Constants::ET_DYNAMIC: + //Write the sealed values to the output stream. + foreach ($propertyNames as $key) { + $this->writeTypeMarker($object->$key); + } + + //Write remaining properties + foreach($object as $key => $value){ + if(!in_array($key,$propertyNames) && $key[0] != "_"){ + $this->writeString($key); + $this->writeTypeMarker($value); + } + } + + //Write an empty string to end the dynamic part + $this->writeString($this->_strEmpty); + break; + case Zend_Amf_Constants::ET_EXTERNAL: + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('External Object Encoding not implemented'); + break; + default: + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Unknown Object Encoding type: ' . $encoding); + } + } catch (Exception $e) { + require_once 'Zend/Amf/Exception.php'; + throw new Zend_Amf_Exception('Unable to writeObject output: ' . $e->getMessage(), 0, $e); + } + + return $this; + } +}