namespace PhpXmlRpc;
use PhpXmlRpc\Helper\Charset;
+use PhpXmlRpc\Helper\Logger;
/**
* This class enables the creation of values for XML-RPC, by encapsulating plain php values.
);
/// @todo: do these need to be public?
+ /** @var Value[]|mixed */
public $me = array();
+ /**
+ * @var int $mytype
+ * @internal
+ */
public $mytype = 0;
+ /** @var string|null $_php_class */
public $_php_class = null;
/**
$this->me['struct'] = $val;
break;
default:
- error_log("XML-RPC: " . __METHOD__ . ": not a known type ($type)");
+ Logger::instance()->errorLog("XML-RPC: " . __METHOD__ . ": not a known type ($type)");
}
}
}
}
if ($typeOf !== 1) {
- error_log("XML-RPC: " . __METHOD__ . ": not a scalar type ($type)");
+ Logger::instance()->errorLog("XML-RPC: " . __METHOD__ . ": not a scalar type ($type)");
return 0;
}
// coerce booleans into correct values
- // NB: we should either do it for datetimes, integers and doubles, too,
+ // NB: we should either do it for datetimes, integers, i8 and doubles, too,
// or just plain remove this check, implemented on booleans only...
if ($type == static::$xmlrpcBoolean) {
if (strcasecmp($val, 'true') == 0 || $val == 1 || ($val == true && strcasecmp($val, 'false'))) {
switch ($this->mytype) {
case 1:
- error_log('XML-RPC: ' . __METHOD__ . ': scalar xmlrpc value can have only one value');
+ Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': scalar xmlrpc value can have only one value');
return 0;
case 3:
- error_log('XML-RPC: ' . __METHOD__ . ': cannot add anonymous scalar to struct xmlrpc value');
+ Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': cannot add anonymous scalar to struct xmlrpc value');
return 0;
case 2:
// we're adding a scalar value to an array here
return 1;
} else {
- error_log('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
+ Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
return 0;
}
}
return 1;
} else {
- error_log('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
+ Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
return 0;
}
}
switch ($this->mytype) {
case 3:
return 'struct';
- break;
case 2:
return 'array';
- break;
case 1:
return 'scalar';
- break;
default:
return 'undef';
}
$rs .= "<${typ}>" . ($val ? '1' : '0') . "</${typ}>";
break;
case static::$xmlrpcString:
- // G. Giunta 2005/2/13: do NOT use htmlentities, since
- // it will produce named html entities, which are invalid xml
+ // Do NOT use htmlentities, since it will produce named html entities, which are invalid xml
$rs .= "<${typ}>" . Charset::instance()->encodeEntities($val, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</${typ}>";
break;
case static::$xmlrpcInt:
// sprintf('%F') could be most likely ok but it fails eg. on 2e-14.
// The code below tries its best at keeping max precision while avoiding exp notation,
// but there is of course no limit in the number of decimal places to be used...
- $rs .= "<${typ}>" . preg_replace('/\\.?0+$/', '', number_format((double)$val, 128, '.', '')) . "</${typ}>";
+ $rs .= "<${typ}>" . preg_replace('/\\.?0+$/', '', number_format((double)$val, PhpXmlRpc::$xmlpc_double_precision, '.', '')) . "</${typ}>";
break;
case static::$xmlrpcDateTime:
if (is_string($val)) {
$rs .= "<struct>\n";
}
$charsetEncoder = Charset::instance();
+ /** @var Value $val2 */
foreach ($val as $key2 => $val2) {
$rs .= '<member><name>' . $charsetEncoder->encodeEntities($key2, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</name>\n";
//$rs.=$this->serializeval($val2);
case 2:
// array
$rs .= "<array>\n<data>\n";
+ /** @var Value $element */
foreach ($val as $element) {
//$rs.=$this->serializeval($val[$i]);
$rs .= $element->serialize($charsetEncoding);
*/
public function serialize($charsetEncoding = '')
{
- // add check? slower, but helps to avoid recursion in serializing broken xmlrpc values...
- //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
- //{
- reset($this->me);
- list($typ, $val) = each($this->me);
+ $val = reset($this->me);
+ $typ = key($this->me);
return '<value>' . $this->serializedata($typ, $val, $charsetEncoding) . "</value>\n";
- //}
}
/**
*/
public function structmemexists($key)
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
return array_key_exists($key, $this->me['struct']);
}
*/
public function structmem($key)
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
return $this->me['struct'][$key];
}
*/
public function structreset()
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
reset($this->me['struct']);
}
* Return next member element for xmlrpc values of type struct.
*
* @return Value
+ * @throws \Error starting with php 8.0, this function should not be used, as it will always throw
*
* @deprecated iterate directly over the object using foreach instead
*/
public function structeach()
{
- return each($this->me['struct']);
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
+ return @each($this->me['struct']);
}
/**
*/
public function scalarval()
{
- reset($this->me);
- list(, $b) = each($this->me);
+ $b = reset($this->me);
return $b;
}
/**
* Returns the type of the xmlrpc value.
*
- * For integers, 'int' is always returned in place of 'i4' or 'i8'.
+ * For integers, 'int' is always returned in place of 'i4'. 'i8' is considered a separate type and returned as such
*
* @return string
*/
public function scalartyp()
{
reset($this->me);
- list($a,) = each($this->me);
- if ($a == static::$xmlrpcI4 || $a == static::$xmlrpcI8) {
+ $a = key($this->me);
+ if ($a == static::$xmlrpcI4) {
$a = static::$xmlrpcInt;
}
*/
public function arraymem($key)
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
return $this->me['array'][$key];
}
*/
public function arraysize()
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
return count($this->me['array']);
}
*/
public function structsize()
{
+ //trigger_error('Method ' . __METHOD__ . ' is deprecated', E_USER_DEPRECATED);
+
return count($this->me['struct']);
}
/**
* Implements the IteratorAggregate interface
*
- * @return ArrayIterator
+ * @return \ArrayIterator
*/
- public function getIterator() {
+ public function getIterator()
+ {
switch ($this->mytype) {
case 3:
return new \ArrayIterator($this->me['struct']);
default:
return new \ArrayIterator();
}
- return new \ArrayIterator();
}
-
- public function offsetSet($offset, $value) {
-
+ /**
+ * @internal required to be public to implement an Interface
+ * @param mixed $offset
+ * @param mixed $value
+ * @throws \Exception
+ */
+ public function offsetSet($offset, $value)
+ {
switch ($this->mytype) {
case 3:
if (!($value instanceof \PhpXmlRpc\Value)) {
}
return;
case 1:
-// todo: handle i4/i8 vs int
+// todo: handle i4 vs int
reset($this->me);
- list($type,) = each($this->me);
+ $type = key($this->me);
if ($type != $offset) {
throw new \Exception('');
}
}
}
- public function offsetExists($offset) {
+ /**
+ * @internal required to be public to implement an Interface
+ * @param mixed $offset
+ * @return bool
+ */
+ public function offsetExists($offset)
+ {
switch ($this->mytype) {
case 3:
return isset($this->me['struct'][$offset]);
case 2:
return isset($this->me['array'][$offset]);
case 1:
-// todo: handle i4/i8 vs int
+// todo: handle i4 vs int
return $offset == $this->scalartyp();
default:
return false;
}
}
- public function offsetUnset($offset) {
+ /**
+ * @internal required to be public to implement an Interface
+ * @param mixed $offset
+ * @throws \Exception
+ */
+ public function offsetUnset($offset)
+ {
switch ($this->mytype) {
case 3:
unset($this->me['struct'][$offset]);
}
}
- public function offsetGet($offset) {
+ /**
+ * @internal required to be public to implement an Interface
+ * @param mixed $offset
+ * @return mixed|Value|null
+ * @throws \Exception
+ */
+ public function offsetGet($offset)
+ {
switch ($this->mytype) {
case 3:
return isset($this->me['struct'][$offset]) ? $this->me['struct'][$offset] : null;
return isset($this->me['array'][$offset]) ? $this->me['array'][$offset] : null;
case 1:
// on bad type: null or exception?
- reset($this->me);
- list($type, $value) = each($this->me);
+ $value = reset($this->me);
+ $type = key($this->me);
return $type == $offset ? $value : null;
default:
// return null or exception?
git://git.onelab.eu / plcapi.git / blobdiff