| Current File : /home/c/i/d/cideo/www/wp-includesVIp/js/crop/images/Server.tar |
Request/Http.php 0000666 00000003276 15125276044 0007646 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @see Zend_Json_Server_Request
*/
require_once 'Zend/Json/Server/Request.php';
/**
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Request_Http extends Zend_Json_Server_Request
{
/**
* Raw JSON pulled from POST body
* @var string
*/
protected $_rawJson;
/**
* Constructor
*
* Pull JSON request from raw POST body and use to populate request.
*
* @return void
*/
public function __construct()
{
$json = file_get_contents('php://input');
$this->_rawJson = $json;
if (!empty($json)) {
$this->loadJson($json);
}
}
/**
* Get JSON from raw POST body
*
* @return string
*/
public function getRawJson()
{
return $this->_rawJson;
}
}
Request.php 0000666 00000014403 15125276044 0006721 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Request
{
/**
* Request ID
* @var mixed
*/
protected $_id;
/**
* Flag
* @var bool
*/
protected $_isMethodError = false;
/**
* Requested method
* @var string
*/
protected $_method;
/**
* Regex for method
* @var string
*/
protected $_methodRegex = '/^[a-z][a-z0-9_]*$/i';
/**
* Request parameters
* @var array
*/
protected $_params = array();
/**
* JSON-RPC version of request
* @var string
*/
protected $_version = '1.0';
/**
* Set request state
*
* @param array $options
* @return Zend_Json_Server_Request
*/
public function setOptions(array $options)
{
$methods = get_class_methods($this);
foreach ($options as $key => $value) {
$method = 'set' . ucfirst($key);
if (in_array($method, $methods)) {
$this->$method($value);
} elseif ($key == 'jsonrpc') {
$this->setVersion($value);
}
}
return $this;
}
/**
* Add a parameter to the request
*
* @param mixed $value
* @param string $key
* @return Zend_Json_Server_Request
*/
public function addParam($value, $key = null)
{
if ((null === $key) || !is_string($key)) {
$index = count($this->_params);
$this->_params[$index] = $value;
} else {
$this->_params[$key] = $value;
}
return $this;
}
/**
* Add many params
*
* @param array $params
* @return Zend_Json_Server_Request
*/
public function addParams(array $params)
{
foreach ($params as $key => $value) {
$this->addParam($value, $key);
}
return $this;
}
/**
* Overwrite params
*
* @param array $params
* @return Zend_Json_Server_Request
*/
public function setParams(array $params)
{
$this->_params = array();
return $this->addParams($params);
}
/**
* Retrieve param by index or key
*
* @param int|string $index
* @return mixed|null Null when not found
*/
public function getParam($index)
{
if (array_key_exists($index, $this->_params)) {
return $this->_params[$index];
}
return null;
}
/**
* Retrieve parameters
*
* @return array
*/
public function getParams()
{
return $this->_params;
}
/**
* Set request method
*
* @param string $name
* @return Zend_Json_Server_Request
*/
public function setMethod($name)
{
if (!preg_match($this->_methodRegex, $name)) {
$this->_isMethodError = true;
} else {
$this->_method = $name;
}
return $this;
}
/**
* Get request method name
*
* @return string
*/
public function getMethod()
{
return $this->_method;
}
/**
* Was a bad method provided?
*
* @return bool
*/
public function isMethodError()
{
return $this->_isMethodError;
}
/**
* Set request identifier
*
* @param mixed $name
* @return Zend_Json_Server_Request
*/
public function setId($name)
{
$this->_id = (string) $name;
return $this;
}
/**
* Retrieve request identifier
*
* @return mixed
*/
public function getId()
{
return $this->_id;
}
/**
* Set JSON-RPC version
*
* @param string $version
* @return Zend_Json_Server_Request
*/
public function setVersion($version)
{
if ('2.0' == $version) {
$this->_version = '2.0';
} else {
$this->_version = '1.0';
}
return $this;
}
/**
* Retrieve JSON-RPC version
*
* @return string
*/
public function getVersion()
{
return $this->_version;
}
/**
* Set request state based on JSON
*
* @param string $json
* @return void
*/
public function loadJson($json)
{
require_once 'Zend/Json.php';
$options = Zend_Json::decode($json);
$this->setOptions($options);
}
/**
* Cast request to JSON
*
* @return string
*/
public function toJson()
{
$jsonArray = array(
'method' => $this->getMethod()
);
if (null !== ($id = $this->getId())) {
$jsonArray['id'] = $id;
}
$params = $this->getParams();
if (!empty($params)) {
$jsonArray['params'] = $params;
}
if ('2.0' == $this->getVersion()) {
$jsonArray['jsonrpc'] = '2.0';
}
require_once 'Zend/Json.php';
return Zend_Json::encode($jsonArray);
}
/**
* Cast request to string (JSON)
*
* @return string
*/
public function __toString()
{
return $this->toJson();
}
}
Cache.php 0000666 00000005336 15125276044 0006301 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id$
*/
/** Zend_Server_Cache */
require_once 'Zend/Server/Cache.php';
/**
* Zend_Json_Server_Cache: cache Zend_Json_Server server definition and SMD
*
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Cache extends Zend_Server_Cache
{
/**
* Cache a service map description (SMD) to a file
*
* Returns true on success, false on failure
*
* @param string $filename
* @param Zend_Json_Server $server
* @return boolean
*/
public static function saveSmd($filename, Zend_Json_Server $server)
{
if (!is_string($filename)
|| (!file_exists($filename) && !is_writable(dirname($filename))))
{
return false;
}
if (0 === @file_put_contents($filename, $server->getServiceMap()->toJson())) {
return false;
}
return true;
}
/**
* Retrieve a cached SMD
*
* On success, returns the cached SMD (a JSON string); an failure, returns
* boolean false.
*
* @param string $filename
* @return string|false
*/
public static function getSmd($filename)
{
if (!is_string($filename)
|| !file_exists($filename)
|| !is_readable($filename))
{
return false;
}
if (false === ($smd = @file_get_contents($filename))) {
return false;
}
return $smd;
}
/**
* Delete a file containing a cached SMD
*
* @param string $filename
* @return bool
*/
public static function deleteSmd($filename)
{
if (is_string($filename) && file_exists($filename)) {
unlink($filename);
return true;
}
return false;
}
}
Response/Http.php 0000666 00000004241 15125276044 0010005 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @see Zend_Json_Server_Response
*/
require_once 'Zend/Json/Server/Response.php';
/**
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Response_Http extends Zend_Json_Server_Response
{
/**
* Emit JSON
*
* Send appropriate HTTP headers. If no Id, then return an empty string.
*
* @return string
*/
public function toJson()
{
$this->sendHeaders();
if (!$this->isError() && null === $this->getId()) {
return '';
}
return parent::toJson();
}
/**
* Send headers
*
* If headers are already sent, do nothing. If null ID, send HTTP 204
* header. Otherwise, send content type header based on content type of
* service map.
*
* @return void
*/
public function sendHeaders()
{
if (headers_sent()) {
return;
}
if (!$this->isError() && (null === $this->getId())) {
header('HTTP/1.1 204 No Content');
return;
}
if (null === ($smd = $this->getServiceMap())) {
return;
}
$contentType = $smd->getContentType();
if (!empty($contentType)) {
header('Content-Type: ' . $contentType);
}
}
}
Smd.php 0000666 00000026621 15125276044 0006021 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Smd
{
const ENV_JSONRPC_1 = 'JSON-RPC-1.0';
const ENV_JSONRPC_2 = 'JSON-RPC-2.0';
const SMD_VERSION = '2.0';
/**
* Content type
* @var string
*/
protected $_contentType = 'application/json';
/**
* Content type regex
* @var string
*/
protected $_contentTypeRegex = '#[a-z]+/[a-z][a-z-]+#i';
/**
* Service description
* @var string
*/
protected $_description;
/**
* Generate Dojo-compatible SMD
* @var bool
*/
protected $_dojoCompatible = false;
/**
* Current envelope
* @var string
*/
protected $_envelope = self::ENV_JSONRPC_1;
/**
* Allowed envelope types
* @var array
*/
protected $_envelopeTypes = array(
self::ENV_JSONRPC_1,
self::ENV_JSONRPC_2,
);
/**
* Service id
* @var string
*/
protected $_id;
/**
* Services offerred
* @var array
*/
protected $_services = array();
/**
* Service target
* @var string
*/
protected $_target;
/**
* Global transport
* @var string
*/
protected $_transport = 'POST';
/**
* Allowed transport types
* @var array
*/
protected $_transportTypes = array('POST');
/**
* Set object state via options
*
* @param array $options
* @return Zend_Json_Server_Smd
*/
public function setOptions(array $options)
{
$methods = get_class_methods($this);
foreach ($options as $key => $value) {
$method = 'set' . ucfirst($key);
if (in_array($method, $methods)) {
$this->$method($value);
}
}
return $this;
}
/**
* Set transport
*
* @param string $transport
* @return Zend_Json_Server_Smd
*/
public function setTransport($transport)
{
if (!in_array($transport, $this->_transportTypes)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid transport "%s" specified', $transport));
}
$this->_transport = $transport;
return $this;
}
/**
* Get transport
*
* @return string
*/
public function getTransport()
{
return $this->_transport;
}
/**
* Set envelope
*
* @param string $envelopeType
* @return Zend_Json_Server_Smd
*/
public function setEnvelope($envelopeType)
{
if (!in_array($envelopeType, $this->_envelopeTypes)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid envelope type "%s"', $envelopeType));
}
$this->_envelope = $envelopeType;
return $this;
}
/**
* Retrieve envelope
*
* @return string
*/
public function getEnvelope()
{
return $this->_envelope;
}
// Content-Type of response; default to application/json
/**
* Set content type
*
* @param string $type
* @return Zend_Json_Server_Smd
*/
public function setContentType($type)
{
if (!preg_match($this->_contentTypeRegex, $type)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid content type "%s" specified', $type));
}
$this->_contentType = $type;
return $this;
}
/**
* Retrieve content type
*
* @return string
*/
public function getContentType()
{
return $this->_contentType;
}
/**
* Set service target
*
* @param string $target
* @return Zend_Json_Server_Smd
*/
public function setTarget($target)
{
$this->_target = (string) $target;
return $this;
}
/**
* Retrieve service target
*
* @return string
*/
public function getTarget()
{
return $this->_target;
}
/**
* Set service ID
*
* @param string $Id
* @return Zend_Json_Server_Smd
*/
public function setId($id)
{
$this->_id = (string) $id;
return $this->_id;
}
/**
* Get service id
*
* @return string
*/
public function getId()
{
return $this->_id;
}
/**
* Set service description
*
* @param string $description
* @return Zend_Json_Server_Smd
*/
public function setDescription($description)
{
$this->_description = (string) $description;
return $this->_description;
}
/**
* Get service description
*
* @return string
*/
public function getDescription()
{
return $this->_description;
}
/**
* Indicate whether or not to generate Dojo-compatible SMD
*
* @param bool $flag
* @return Zend_Json_Server_Smd
*/
public function setDojoCompatible($flag)
{
$this->_dojoCompatible = (bool) $flag;
return $this;
}
/**
* Is this a Dojo compatible SMD?
*
* @return bool
*/
public function isDojoCompatible()
{
return $this->_dojoCompatible;
}
/**
* Add Service
*
* @param Zend_Json_Server_Smd_Service|array $service
* @return void
*/
public function addService($service)
{
require_once 'Zend/Json/Server/Smd/Service.php';
if ($service instanceof Zend_Json_Server_Smd_Service) {
$name = $service->getName();
} elseif (is_array($service)) {
$service = new Zend_Json_Server_Smd_Service($service);
$name = $service->getName();
} else {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Invalid service passed to addService()');
}
if (array_key_exists($name, $this->_services)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Attempt to register a service already registered detected');
}
$this->_services[$name] = $service;
return $this;
}
/**
* Add many services
*
* @param array $services
* @return Zend_Json_Server_Smd
*/
public function addServices(array $services)
{
foreach ($services as $service) {
$this->addService($service);
}
return $this;
}
/**
* Overwrite existing services with new ones
*
* @param array $services
* @return Zend_Json_Server_Smd
*/
public function setServices(array $services)
{
$this->_services = array();
return $this->addServices($services);
}
/**
* Get service object
*
* @param string $name
* @return false|Zend_Json_Server_Smd_Service
*/
public function getService($name)
{
if (array_key_exists($name, $this->_services)) {
return $this->_services[$name];
}
return false;
}
/**
* Return services
*
* @return array
*/
public function getServices()
{
return $this->_services;
}
/**
* Remove service
*
* @param string $name
* @return boolean
*/
public function removeService($name)
{
if (array_key_exists($name, $this->_services)) {
unset($this->_services[$name]);
return true;
}
return false;
}
/**
* Cast to array
*
* @return array
*/
public function toArray()
{
if ($this->isDojoCompatible()) {
return $this->toDojoArray();
}
$transport = $this->getTransport();
$envelope = $this->getEnvelope();
$contentType = $this->getContentType();
$SMDVersion = self::SMD_VERSION;
$service = compact('transport', 'envelope', 'contentType', 'SMDVersion');
if (null !== ($target = $this->getTarget())) {
$service['target'] = $target;
}
if (null !== ($id = $this->getId())) {
$service['id'] = $id;
}
$services = $this->getServices();
if (!empty($services)) {
$service['services'] = array();
foreach ($services as $name => $svc) {
$svc->setEnvelope($envelope);
$service['services'][$name] = $svc->toArray();
}
$service['methods'] = $service['services'];
}
return $service;
}
/**
* Export to DOJO-compatible SMD array
*
* @return array
*/
public function toDojoArray()
{
$SMDVersion = '.1';
$serviceType = 'JSON-RPC';
$service = compact('SMDVersion', 'serviceType');
$target = $this->getTarget();
$services = $this->getServices();
if (!empty($services)) {
$service['methods'] = array();
foreach ($services as $name => $svc) {
$method = array(
'name' => $name,
'serviceURL' => $target,
);
$params = array();
foreach ($svc->getParams() as $param) {
$paramName = array_key_exists('name', $param) ? $param['name'] : $param['type'];
$params[] = array(
'name' => $paramName,
'type' => $param['type'],
);
}
if (!empty($params)) {
$method['parameters'] = $params;
}
$service['methods'][] = $method;
}
}
return $service;
}
/**
* Cast to JSON
*
* @return string
*/
public function toJson()
{
require_once 'Zend/Json.php';
return Zend_Json::encode($this->toArray());
}
/**
* Cast to string (JSON)
*
* @return string
*/
public function __toString()
{
return $this->toJson();
}
}
Error.php 0000666 00000010341 15125276044 0006357 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Error
{
const ERROR_PARSE = -32768;
const ERROR_INVALID_REQUEST = -32600;
const ERROR_INVALID_METHOD = -32601;
const ERROR_INVALID_PARAMS = -32602;
const ERROR_INTERNAL = -32603;
const ERROR_OTHER = -32000;
/**
* Allowed error codes
* @var array
*/
protected $_allowedCodes = array(
self::ERROR_PARSE,
self::ERROR_INVALID_REQUEST,
self::ERROR_INVALID_METHOD,
self::ERROR_INVALID_PARAMS,
self::ERROR_INTERNAL,
self::ERROR_OTHER,
);
/**
* Current code
* @var int
*/
protected $_code = -32000;
/**
* Error data
* @var mixed
*/
protected $_data;
/**
* Error message
* @var string
*/
protected $_message;
/**
* Constructor
*
* @param string $message
* @param int $code
* @param mixed $data
* @return void
*/
public function __construct($message = null, $code = -32000, $data = null)
{
$this->setMessage($message)
->setCode($code)
->setData($data);
}
/**
* Set error code
*
* @param int $code
* @return Zend_Json_Server_Error
*/
public function setCode($code)
{
if (!is_scalar($code)) {
return $this;
}
$code = (int) $code;
if (in_array($code, $this->_allowedCodes)) {
$this->_code = $code;
} elseif (in_array($code, range(-32099, -32000))) {
$this->_code = $code;
}
return $this;
}
/**
* Get error code
*
* @return int|null
*/
public function getCode()
{
return $this->_code;
}
/**
* Set error message
*
* @param string $message
* @return Zend_Json_Server_Error
*/
public function setMessage($message)
{
if (!is_scalar($message)) {
return $this;
}
$this->_message = (string) $message;
return $this;
}
/**
* Get error message
*
* @return string
*/
public function getMessage()
{
return $this->_message;
}
/**
* Set error data
*
* @param mixed $data
* @return Zend_Json_Server_Error
*/
public function setData($data)
{
$this->_data = $data;
return $this;
}
/**
* Get error data
*
* @return mixed
*/
public function getData()
{
return $this->_data;
}
/**
* Cast error to array
*
* @return array
*/
public function toArray()
{
return array(
'code' => $this->getCode(),
'message' => $this->getMessage(),
'data' => $this->getData(),
);
}
/**
* Cast error to JSON
*
* @return string
*/
public function toJson()
{
require_once 'Zend/Json.php';
return Zend_Json::encode($this->toArray());
}
/**
* Cast to string (JSON)
*
* @return string
*/
public function __toString()
{
return $this->toJson();
}
}
Exception.php 0000666 00000002130 15125276044 0007221 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @package Zend_Rest
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* Zend_Rest_Exception
*/
require_once 'Zend/Rest/Exception.php';
/**
* Zend_Rest_Server_Exception
*
* @package Zend_Rest
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Rest_Server_Exception extends Zend_Rest_Exception
{
}
Response.php 0000666 00000011773 15125276044 0007076 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @category Zend
* @package Zend_Json
* @subpackage Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Response
{
/**
* Response error
* @var null|Zend_Json_Server_Error
*/
protected $_error;
/**
* Request ID
* @var mixed
*/
protected $_id;
/**
* Result
* @var mixed
*/
protected $_result;
/**
* Service map
* @var Zend_Json_Server_Smd
*/
protected $_serviceMap;
/**
* JSON-RPC version
* @var string
*/
protected $_version;
/**
* Set result
*
* @param mixed $value
* @return Zend_Json_Server_Response
*/
public function setResult($value)
{
$this->_result = $value;
return $this;
}
/**
* Get result
*
* @return mixed
*/
public function getResult()
{
return $this->_result;
}
// RPC error, if response results in fault
/**
* Set result error
*
* @param Zend_Json_Server_Error $error
* @return Zend_Json_Server_Response
*/
public function setError(Zend_Json_Server_Error $error)
{
$this->_error = $error;
return $this;
}
/**
* Get response error
*
* @return null|Zend_Json_Server_Error
*/
public function getError()
{
return $this->_error;
}
/**
* Is the response an error?
*
* @return bool
*/
public function isError()
{
return $this->getError() instanceof Zend_Json_Server_Error;
}
/**
* Set request ID
*
* @param mixed $name
* @return Zend_Json_Server_Response
*/
public function setId($name)
{
$this->_id = $name;
return $this;
}
/**
* Get request ID
*
* @return mixed
*/
public function getId()
{
return $this->_id;
}
/**
* Set JSON-RPC version
*
* @param string $version
* @return Zend_Json_Server_Response
*/
public function setVersion($version)
{
$version = (string) $version;
if ('2.0' == $version) {
$this->_version = '2.0';
} else {
$this->_version = null;
}
return $this;
}
/**
* Retrieve JSON-RPC version
*
* @return string
*/
public function getVersion()
{
return $this->_version;
}
/**
* Cast to JSON
*
* @return string
*/
public function toJson()
{
if ($this->isError()) {
$response = array(
'error' => $this->getError()->toArray(),
'id' => $this->getId(),
);
} else {
$response = array(
'result' => $this->getResult(),
'id' => $this->getId(),
);
}
if (null !== ($version = $this->getVersion())) {
$response['jsonrpc'] = $version;
}
require_once 'Zend/Json.php';
return Zend_Json::encode($response);
}
/**
* Retrieve args
*
* @return mixed
*/
public function getArgs()
{
return $this->_args;
}
/**
* Set args
*
* @param mixed $args
* @return self
*/
public function setArgs($args)
{
$this->_args = $args;
return $this;
}
/**
* Set service map object
*
* @param Zend_Json_Server_Smd $serviceMap
* @return Zend_Json_Server_Response
*/
public function setServiceMap($serviceMap)
{
$this->_serviceMap = $serviceMap;
return $this;
}
/**
* Retrieve service map
*
* @return Zend_Json_Server_Smd|null
*/
public function getServiceMap()
{
return $this->_serviceMap;
}
/**
* Cast to string (JSON)
*
* @return string
*/
public function __toString()
{
return $this->toJson();
}
}
Smd/Service.php 0000666 00000030674 15125276044 0007424 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Json
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @see Zend_Json_Server_Smd
*/
require_once 'Zend/Json/Server/Smd.php';
/**
* Create Service Mapping Description for a method
*
* @package Zend_Json
* @subpackage Server
* @version $Id: Service.php 12510 2008-11-10 16:29:34Z matthew $
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Json_Server_Smd_Service
{
/**#@+
* Service metadata
* @var string
*/
protected $_envelope = Zend_Json_Server_Smd::ENV_JSONRPC_1;
protected $_name;
protected $_return;
protected $_target;
protected $_transport = 'POST';
/**#@-*/
/**
* Allowed envelope types
* @var array
*/
protected $_envelopeTypes = array(
Zend_Json_Server_Smd::ENV_JSONRPC_1,
Zend_Json_Server_Smd::ENV_JSONRPC_2,
);
/**
* Regex for names
* @var string
*/
protected $_nameRegex = '/^[a-z][a-z0-9._]+$/i';
/**
* Parameter option types
* @var array
*/
protected $_paramOptionTypes = array(
'name' => 'is_string',
'optional' => 'is_bool',
'default' => null,
'description' => 'is_string',
);
/**
* Service params
* @var array
*/
protected $_params = array();
/**
* Mapping of parameter types to JSON-RPC types
* @var array
*/
protected $_paramMap = array(
'any' => 'any',
'arr' => 'array',
'array' => 'array',
'assoc' => 'object',
'bool' => 'boolean',
'boolean' => 'boolean',
'dbl' => 'float',
'double' => 'float',
'false' => 'boolean',
'float' => 'float',
'hash' => 'object',
'integer' => 'integer',
'int' => 'integer',
'mixed' => 'any',
'nil' => 'null',
'null' => 'null',
'object' => 'object',
'string' => 'string',
'str' => 'string',
'struct' => 'object',
'true' => 'boolean',
'void' => 'null',
);
/**
* Allowed transport types
* @var array
*/
protected $_transportTypes = array(
'POST',
);
/**
* Constructor
*
* @param string|array $spec
* @return void
* @throws Zend_Json_Server_Exception if no name provided
*/
public function __construct($spec)
{
if (is_string($spec)) {
$this->setName($spec);
} elseif (is_array($spec)) {
$this->setOptions($spec);
}
if (null == $this->getName()) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('SMD service description requires a name; none provided');
}
}
/**
* Set object state
*
* @param array $options
* @return Zend_Json_Server_Smd_Service
*/
public function setOptions(array $options)
{
$methods = get_class_methods($this);
foreach ($options as $key => $value) {
if ('options' == strtolower($key)) {
continue;
}
$method = 'set' . ucfirst($key);
if (in_array($method, $methods)) {
$this->$method($value);
}
}
return $this;
}
/**
* Set service name
*
* @param string $name
* @return Zend_Json_Server_Smd_Service
* @throws Zend_Json_Server_Exception
*/
public function setName($name)
{
$name = (string) $name;
if (!preg_match($this->_nameRegex, $name)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid name "%s" provided for service; must follow PHP method naming conventions', $name));
}
$this->_name = $name;
return $this;
}
/**
* Retrieve name
*
* @return string
*/
public function getName()
{
return $this->_name;
}
/**
* Set Transport
*
* Currently limited to POST
*
* @param string $transport
* @return Zend_Json_Server_Smd_Service
*/
public function setTransport($transport)
{
if (!in_array($transport, $this->_transportTypes)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid transport "%s"; please select one of (%s)', $transport, implode(', ', $this->_transportTypes)));
}
$this->_transport = $transport;
return $this;
}
/**
* Get transport
*
* @return string
*/
public function getTransport()
{
return $this->_transport;
}
/**
* Set service target
*
* @param string $target
* @return Zend_Json_Server_Smd_Service
*/
public function setTarget($target)
{
$this->_target = (string) $target;
return $this;
}
/**
* Get service target
*
* @return string
*/
public function getTarget()
{
return $this->_target;
}
/**
* Set envelope type
*
* @param string $envelopeType
* @return Zend_Json_Server_Smd_Service
*/
public function setEnvelope($envelopeType)
{
if (!in_array($envelopeType, $this->_envelopeTypes)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception(sprintf('Invalid envelope type "%s"; please specify one of (%s)', $envelopeType, implode(', ', $this->_envelopeTypes)));
}
$this->_envelope = $envelopeType;
return $this;
}
/**
* Get envelope type
*
* @return string
*/
public function getEnvelope()
{
return $this->_envelope;
}
/**
* Add a parameter to the service
*
* @param string|array $type
* @param array $options
* @param int|null $order
* @return Zend_Json_Server_Smd_Service
*/
public function addParam($type, array $options = array(), $order = null)
{
if (is_string($type)) {
$type = $this->_validateParamType($type);
} elseif (is_array($type)) {
foreach ($type as $key => $paramType) {
$type[$key] = $this->_validateParamType($paramType);
}
} else {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Invalid param type provided');
}
$paramOptions = array(
'type' => $type,
);
foreach ($options as $key => $value) {
if (in_array($key, array_keys($this->_paramOptionTypes))) {
if (null !== ($callback = $this->_paramOptionTypes[$key])) {
if (!$callback($value)) {
continue;
}
}
$paramOptions[$key] = $value;
}
}
$this->_params[] = array(
'param' => $paramOptions,
'order' => $order,
);
return $this;
}
/**
* Add params
*
* Each param should be an array, and should include the key 'type'.
*
* @param array $params
* @return Zend_Json_Server_Smd_Service
*/
public function addParams(array $params)
{
ksort($params);
foreach ($params as $options) {
if (!is_array($options)) {
continue;
}
if (!array_key_exists('type', $options)) {
continue;
}
$type = $options['type'];
$order = (array_key_exists('order', $options)) ? $options['order'] : null;
$this->addParam($type, $options, $order);
}
return $this;
}
/**
* Overwrite all parameters
*
* @param array $params
* @return Zend_Json_Server_Smd_Service
*/
public function setParams(array $params)
{
$this->_params = array();
return $this->addParams($params);
}
/**
* Get all parameters
*
* Returns all params in specified order.
*
* @return array
*/
public function getParams()
{
$params = array();
$index = 0;
foreach ($this->_params as $param) {
if (null === $param['order']) {
if (array_search($index, array_keys($params), true)) {
++$index;
}
$params[$index] = $param['param'];
++$index;
} else {
$params[$param['order']] = $param['param'];
}
}
ksort($params);
return $params;
}
/**
* Set return type
*
* @param string|array $type
* @return Zend_Json_Server_Smd_Service
*/
public function setReturn($type)
{
if (is_string($type)) {
$type = $this->_validateParamType($type, true);
} elseif (is_array($type)) {
foreach ($type as $key => $returnType) {
$type[$key] = $this->_validateParamType($returnType, true);
}
} else {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Invalid param type provided ("' . gettype($type) .'")');
}
$this->_return = $type;
return $this;
}
/**
* Get return type
*
* @return string|array
*/
public function getReturn()
{
return $this->_return;
}
/**
* Cast service description to array
*
* @return array
*/
public function toArray()
{
$name = $this->getName();
$envelope = $this->getEnvelope();
$target = $this->getTarget();
$transport = $this->getTransport();
$parameters = $this->getParams();
$returns = $this->getReturn();
if (empty($target)) {
return compact('envelope', 'transport', 'parameters', 'returns');
}
return $paramInfo = compact('envelope', 'target', 'transport', 'parameters', 'returns');
}
/**
* Return JSON encoding of service
*
* @return string
*/
public function toJson()
{
$service = array($this->getName() => $this->toArray());
require_once 'Zend/Json.php';
return Zend_Json::encode($service);
}
/**
* Cast to string
*
* @return string
*/
public function __toString()
{
return $this->toJson();
}
/**
* Validate parameter type
*
* @param string $type
* @return true
* @throws Zend_Json_Server_Exception
*/
protected function _validateParamType($type, $isReturn = false)
{
if (!is_string($type)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Invalid param type provided ("' . $type .'")');
}
if (!array_key_exists($type, $this->_paramMap)) {
$type = 'object';
}
$paramType = $this->_paramMap[$type];
if (!$isReturn && ('null' == $paramType)) {
require_once 'Zend/Json/Server/Exception.php';
throw new Zend_Json_Server_Exception('Invalid param type provided ("' . $type . '")');
}
return $paramType;
}
}
Reflection/Parameter.php 0000666 00000007523 15125711741 0011306 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* Zend_Server_Reflection_Exception
*/
require_once 'Zend/Server/Reflection/Exception.php';
/**
* Parameter Reflection
*
* Decorates a ReflectionParameter to allow setting the parameter type
*
* @category Zend
* @package Zend_Server
* @subpackage Reflection
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: Parameter.php 12619 2008-11-13 15:24:29Z alexander $
*/
class Zend_Server_Reflection_Parameter
{
/**
* @var ReflectionParameter
*/
protected $_reflection;
/**
* Parameter position
* @var int
*/
protected $_position;
/**
* Parameter type
* @var string
*/
protected $_type;
/**
* Parameter description
* @var string
*/
protected $_description;
/**
* Constructor
*
* @param ReflectionParameter $r
* @param string $type Parameter type
* @param string $description Parameter description
*/
public function __construct(ReflectionParameter $r, $type = 'mixed', $description = '')
{
$this->_reflection = $r;
$this->setType($type);
$this->setDescription($description);
}
/**
* Proxy reflection calls
*
* @param string $method
* @param array $args
* @return mixed
*/
public function __call($method, $args)
{
if (method_exists($this->_reflection, $method)) {
return call_user_func_array(array($this->_reflection, $method), $args);
}
throw new Zend_Server_Reflection_Exception('Invalid reflection method');
}
/**
* Retrieve parameter type
*
* @return string
*/
public function getType()
{
return $this->_type;
}
/**
* Set parameter type
*
* @param string|null $type
* @return void
*/
public function setType($type)
{
if (!is_string($type) && (null !== $type)) {
throw new Zend_Server_Reflection_Exception('Invalid parameter type');
}
$this->_type = $type;
}
/**
* Retrieve parameter description
*
* @return string
*/
public function getDescription()
{
return $this->_description;
}
/**
* Set parameter description
*
* @param string|null $description
* @return void
*/
public function setDescription($description)
{
if (!is_string($description) && (null !== $description)) {
throw new Zend_Server_Reflection_Exception('Invalid parameter description');
}
$this->_description = $description;
}
/**
* Set parameter position
*
* @param int $index
* @return void
*/
public function setPosition($index)
{
$this->_position = (int) $index;
}
/**
* Return parameter position
*
* @return int
*/
public function getPosition()
{
return $this->_position;
}
}
Reflection/Function/Abstract.php 0000666 00000036647 15125711741 0012727 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* Zend_Server_Reflection_Exception
*/
require_once 'Zend/Server/Reflection/Exception.php';
/**
* Zend_Server_Reflection_Node
*/
require_once 'Zend/Server/Reflection/Node.php';
/**
* Zend_Server_Reflection_Parameter
*/
require_once 'Zend/Server/Reflection/Parameter.php';
/**
* Zend_Server_Reflection_Prototype
*/
require_once 'Zend/Server/Reflection/Prototype.php';
/**
* Function/Method Reflection
*
* Decorates a ReflectionFunction. Allows setting and retrieving an alternate
* 'service' name (i.e., the name to be used when calling via a service),
* setting and retrieving the description (originally set using the docblock
* contents), retrieving the callback and callback type, retrieving additional
* method invocation arguments, and retrieving the
* method {@link Zend_Server_Reflection_Prototype prototypes}.
*
* @category Zend
* @package Zend_Server
* @subpackage Reflection
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: Abstract.php 12619 2008-11-13 15:24:29Z alexander $
*/
abstract class Zend_Server_Reflection_Function_Abstract
{
/**
* @var ReflectionFunction
*/
protected $_reflection;
/**
* Additional arguments to pass to method on invocation
* @var array
*/
protected $_argv = array();
/**
* Used to store extra configuration for the method (typically done by the
* server class, e.g., to indicate whether or not to instantiate a class).
* Associative array; access is as properties via {@link __get()} and
* {@link __set()}
* @var array
*/
protected $_config = array();
/**
* Declaring class (needed for when serialization occurs)
* @var string
*/
protected $_class;
/**
* Function/method description
* @var string
*/
protected $_description = '';
/**
* Namespace with which to prefix function/method name
* @var string
*/
protected $_namespace;
/**
* Prototypes
* @var array
*/
protected $_prototypes = array();
private $_return;
private $_returnDesc;
private $_paramDesc;
private $_sigParams;
private $_sigParamsDepth;
/**
* Constructor
*
* @param ReflectionFunction $r
*/
public function __construct(Reflector $r, $namespace = null, $argv = array())
{
// In PHP 5.1.x, ReflectionMethod extends ReflectionFunction. In 5.2.x,
// both extend ReflectionFunctionAbstract. So, we can't do normal type
// hinting in the prototype, but instead need to do some explicit
// testing here.
if ((!$r instanceof ReflectionFunction)
&& (!$r instanceof ReflectionMethod)) {
throw new Zend_Server_Reflection_Exception('Invalid reflection class');
}
$this->_reflection = $r;
// Determine namespace
if (null !== $namespace){
$this->setNamespace($namespace);
}
// Determine arguments
if (is_array($argv)) {
$this->_argv = $argv;
}
// If method call, need to store some info on the class
if ($r instanceof ReflectionMethod) {
$this->_class = $r->getDeclaringClass()->getName();
}
// Perform some introspection
$this->_reflect();
}
/**
* Create signature node tree
*
* Recursive method to build the signature node tree. Increments through
* each array in {@link $_sigParams}, adding every value of the next level
* to the current value (unless the current value is null).
*
* @param Zend_Server_Reflection_Node $parent
* @param int $level
* @return void
*/
protected function _addTree(Zend_Server_Reflection_Node $parent, $level = 0)
{
if ($level >= $this->_sigParamsDepth) {
return;
}
foreach ($this->_sigParams[$level] as $value) {
$node = new Zend_Server_Reflection_Node($value, $parent);
if ((null !== $value) && ($this->_sigParamsDepth > $level + 1)) {
$this->_addTree($node, $level + 1);
}
}
}
/**
* Build the signature tree
*
* Builds a signature tree starting at the return values and descending
* through each method argument. Returns an array of
* {@link Zend_Server_Reflection_Node}s.
*
* @return array
*/
protected function _buildTree()
{
$returnTree = array();
foreach ((array) $this->_return as $value) {
$node = new Zend_Server_Reflection_Node($value);
$this->_addTree($node);
$returnTree[] = $node;
}
return $returnTree;
}
/**
* Build method signatures
*
* Builds method signatures using the array of return types and the array of
* parameters types
*
* @param array $return Array of return types
* @param string $returnDesc Return value description
* @param array $params Array of arguments (each an array of types)
* @param array $paramDesc Array of parameter descriptions
* @return array
*/
protected function _buildSignatures($return, $returnDesc, $paramTypes, $paramDesc)
{
$this->_return = $return;
$this->_returnDesc = $returnDesc;
$this->_paramDesc = $paramDesc;
$this->_sigParams = $paramTypes;
$this->_sigParamsDepth = count($paramTypes);
$signatureTrees = $this->_buildTree();
$signatures = array();
$endPoints = array();
foreach ($signatureTrees as $root) {
$tmp = $root->getEndPoints();
if (empty($tmp)) {
$endPoints = array_merge($endPoints, array($root));
} else {
$endPoints = array_merge($endPoints, $tmp);
}
}
foreach ($endPoints as $node) {
if (!$node instanceof Zend_Server_Reflection_Node) {
continue;
}
$signature = array();
do {
array_unshift($signature, $node->getValue());
$node = $node->getParent();
} while ($node instanceof Zend_Server_Reflection_Node);
$signatures[] = $signature;
}
// Build prototypes
$params = $this->_reflection->getParameters();
foreach ($signatures as $signature) {
$return = new Zend_Server_Reflection_ReturnValue(array_shift($signature), $this->_returnDesc);
$tmp = array();
foreach ($signature as $key => $type) {
$param = new Zend_Server_Reflection_Parameter($params[$key], $type, $this->_paramDesc[$key]);
$param->setPosition($key);
$tmp[] = $param;
}
$this->_prototypes[] = new Zend_Server_Reflection_Prototype($return, $tmp);
}
}
/**
* Use code reflection to create method signatures
*
* Determines the method help/description text from the function DocBlock
* comment. Determines method signatures using a combination of
* ReflectionFunction and parsing of DocBlock @param and @return values.
*
* @param ReflectionFunction $function
* @return array
*/
protected function _reflect()
{
$function = $this->_reflection;
$helpText = '';
$signatures = array();
$returnDesc = '';
$paramCount = $function->getNumberOfParameters();
$paramCountRequired = $function->getNumberOfRequiredParameters();
$parameters = $function->getParameters();
$docBlock = $function->getDocComment();
if (!empty($docBlock)) {
// Get help text
if (preg_match(':/\*\*\s*\r?\n\s*\*\s(.*?)\r?\n\s*\*(\s@|/):s', $docBlock, $matches))
{
$helpText = $matches[1];
$helpText = preg_replace('/(^\s*\*\s)/m', '', $helpText);
$helpText = preg_replace('/\r?\n\s*\*\s*(\r?\n)*/s', "\n", $helpText);
$helpText = trim($helpText);
}
// Get return type(s) and description
$return = 'void';
if (preg_match('/@return\s+(\S+)/', $docBlock, $matches)) {
$return = explode('|', $matches[1]);
if (preg_match('/@return\s+\S+\s+(.*?)(@|\*\/)/s', $docBlock, $matches))
{
$value = $matches[1];
$value = preg_replace('/\s?\*\s/m', '', $value);
$value = preg_replace('/\s{2,}/', ' ', $value);
$returnDesc = trim($value);
}
}
// Get param types and description
if (preg_match_all('/@param\s+([^\s]+)/m', $docBlock, $matches)) {
$paramTypesTmp = $matches[1];
if (preg_match_all('/@param\s+\S+\s+(\$^\S+)\s+(.*?)(@|\*\/)/s', $docBlock, $matches))
{
$paramDesc = $matches[2];
foreach ($paramDesc as $key => $value) {
$value = preg_replace('/\s?\*\s/m', '', $value);
$value = preg_replace('/\s{2,}/', ' ', $value);
$paramDesc[$key] = trim($value);
}
}
}
} else {
$helpText = $function->getName();
$return = 'void';
}
// Set method description
$this->setDescription($helpText);
// Get all param types as arrays
if (!isset($paramTypesTmp) && (0 < $paramCount)) {
$paramTypesTmp = array_fill(0, $paramCount, 'mixed');
} elseif (!isset($paramTypesTmp)) {
$paramTypesTmp = array();
} elseif (count($paramTypesTmp) < $paramCount) {
$start = $paramCount - count($paramTypesTmp);
for ($i = $start; $i < $paramCount; ++$i) {
$paramTypesTmp[$i] = 'mixed';
}
}
// Get all param descriptions as arrays
if (!isset($paramDesc) && (0 < $paramCount)) {
$paramDesc = array_fill(0, $paramCount, '');
} elseif (!isset($paramDesc)) {
$paramDesc = array();
} elseif (count($paramDesc) < $paramCount) {
$start = $paramCount - count($paramDesc);
for ($i = $start; $i < $paramCount; ++$i) {
$paramDesc[$i] = '';
}
}
if (count($paramTypesTmp) != $paramCount) {
throw new Zend_Server_Reflection_Exception(
'Variable number of arguments is not supported for services (except optional parameters). '
. 'Number of function arguments must currespond to actual number of arguments described in a docblock.');
}
$paramTypes = array();
foreach ($paramTypesTmp as $i => $param) {
$tmp = explode('|', $param);
if ($parameters[$i]->isOptional()) {
array_unshift($tmp, null);
}
$paramTypes[] = $tmp;
}
$this->_buildSignatures($return, $returnDesc, $paramTypes, $paramDesc);
}
/**
* Proxy reflection calls
*
* @param string $method
* @param array $args
* @return mixed
*/
public function __call($method, $args)
{
if (method_exists($this->_reflection, $method)) {
return call_user_func_array(array($this->_reflection, $method), $args);
}
throw new Zend_Server_Reflection_Exception('Invalid reflection method ("' .$method. '")');
}
/**
* Retrieve configuration parameters
*
* Values are retrieved by key from {@link $_config}. Returns null if no
* value found.
*
* @param string $key
* @return mixed
*/
public function __get($key)
{
if (isset($this->_config[$key])) {
return $this->_config[$key];
}
return null;
}
/**
* Set configuration parameters
*
* Values are stored by $key in {@link $_config}.
*
* @param string $key
* @param mixed $value
* @return void
*/
public function __set($key, $value)
{
$this->_config[$key] = $value;
}
/**
* Set method's namespace
*
* @param string $namespace
* @return void
*/
public function setNamespace($namespace)
{
if (empty($namespace)) {
$this->_namespace = '';
return;
}
if (!is_string($namespace) || !preg_match('/[a-z0-9_\.]+/i', $namespace)) {
throw new Zend_Server_Reflection_Exception('Invalid namespace');
}
$this->_namespace = $namespace;
}
/**
* Return method's namespace
*
* @return string
*/
public function getNamespace()
{
return $this->_namespace;
}
/**
* Set the description
*
* @param string $string
* @return void
*/
public function setDescription($string)
{
if (!is_string($string)) {
throw new Zend_Server_Reflection_Exception('Invalid description');
}
$this->_description = $string;
}
/**
* Retrieve the description
*
* @return void
*/
public function getDescription()
{
return $this->_description;
}
/**
* Retrieve all prototypes as array of
* {@link Zend_Server_Reflection_Prototype Zend_Server_Reflection_Prototypes}
*
* @return array
*/
public function getPrototypes()
{
return $this->_prototypes;
}
/**
* Retrieve additional invocation arguments
*
* @return array
*/
public function getInvokeArguments()
{
return $this->_argv;
}
/**
* Wakeup from serialization
*
* Reflection needs explicit instantiation to work correctly. Re-instantiate
* reflection object on wakeup.
*
* @return void
*/
public function __wakeup()
{
if ($this->_reflection instanceof ReflectionMethod) {
$class = new ReflectionClass($this->_class);
$this->_reflection = new ReflectionMethod($class->newInstance(), $this->getName());
} else {
$this->_reflection = new ReflectionFunction($this->getName());
}
}
}
Reflection/ReturnValue.php 0000666 00000005430 15125711741 0011635 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Server
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* Zend_Server_Reflection_Exception
*/
require_once 'Zend/Server/Reflection/Exception.php';
/**
* Return value reflection
*
* Stores the return value type and description
*
* @category Zend
* @package Zend_Server
* @subpackage Reflection
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: ReturnValue.php 12619 2008-11-13 15:24:29Z alexander $
*/
class Zend_Server_Reflection_ReturnValue
{
/**
* Return value type
* @var string
*/
protected $_type;
/**
* Return value description
* @var string
*/
protected $_description;
/**
* Constructor
*
* @param string $type Return value type
* @param string $description Return value type
*/
public function __construct($type = 'mixed', $description = '')
{
$this->setType($type);
$this->setDescription($description);
}
/**
* Retrieve parameter type
*
* @return string
*/
public function getType()
{
return $this->_type;
}
/**
* Set parameter type
*
* @param string|null $type
* @return void
*/
public function setType($type)
{
if (!is_string($type) && (null !== $type)) {
throw new Zend_Server_Reflection_Exception('Invalid parameter type');
}
$this->_type = $type;
}
/**
* Retrieve parameter description
*
* @return string
*/
public function getDescription()
{
return $this->_description;
}
/**
* Set parameter description
*
* @param string|null $description
* @return void
*/
public function setDescription($description)
{
if (!is_string($description) && (null !== $description)) {
throw new Zend_Server_Reflection_Exception('Invalid parameter description');
}
$this->_description = $description;
}
}