PHP Parameter::filter方法代码示例

protected function resolveRecursively(array $value, Parameter $param)
{
foreach ($value as $name => &$v) {
switch ($param->getType()) {
case 'object':
if ($subParam = $param->getProperty($name)) {
$key = $subParam->getWireName();
$value[$key] = $this->prepareValue($v, $subParam);
if ($name != $key) {
unset($value[$name]);
}
} elseif ($param->getAdditionalProperties() instanceof Parameter) {
$v = $this->prepareValue($v, $param->getAdditionalProperties());
}
break;
case 'array':
if ($items = $param->getItems()) {
$v = $this->prepareValue($v, $items);
}
break;
}
}

return $param->filter($value);
}

 protected function addXml(\XMLWriter $xmlWriter, Parameter $param, $value)
 {
     if ($value === null) {
         return;
     }
     $value = $param->filter($value);
     $type = $param->getType();
     $name = $param->getWireName();
     $prefix = null;
     $namespace = $param->getData('xmlNamespace');
     if (false !== strpos($name, ':')) {
         list($prefix, $name) = explode(':', $name, 2);
     }
     if ($type == 'object' || $type == 'array') {
         if (!$param->getData('xmlFlattened')) {
             $xmlWriter->startElementNS(null, $name, $namespace);
         }
         if ($param->getType() == 'array') {
             $this->addXmlArray($xmlWriter, $param, $value);
         } elseif ($param->getType() == 'object') {
             $this->addXmlObject($xmlWriter, $param, $value);
         }
         if (!$param->getData('xmlFlattened')) {
             $xmlWriter->endElement();
         }
         return;
     }
     if ($param->getData('xmlAttribute')) {
         $this->writeAttribute($xmlWriter, $prefix, $name, $namespace, $value);
     } else {
         $this->writeElement($xmlWriter, $prefix, $name, $namespace, $value);
     }
 }

 /**
  * Recursively process a parameter while applying filters
  *
  * @param Parameter $param API parameter being validated
  * @param mixed     $value Value to validate and process. The value may change during this process.
  */
 protected function recursiveProcess(Parameter $param, &$value)
 {
     if ($value === null) {
         return;
     }
     if (is_array($value)) {
         $type = $param->getType();
         if ($type == 'array') {
             foreach ($value as &$item) {
                 $this->recursiveProcess($param->getItems(), $item);
             }
         } elseif ($type == 'object' && !isset($value[0])) {
             // On the above line, we ensure that the array is associative and not numerically indexed
             if ($properties = $param->getProperties()) {
                 foreach ($properties as $property) {
                     $name = $property->getName();
                     $key = $property->getWireName();
                     if (isset($value[$key])) {
                         $this->recursiveProcess($property, $value[$key]);
                         if ($key != $name) {
                             $value[$name] = $value[$key];
                             unset($value[$key]);
                         }
                     }
                 }
             }
         }
     }
     $value = $param->filter($value);
 }

public function visit(
CommandInterface $command,
Response $response,
Parameter $param,
&$value,
$context = null
) {
$value[$param->getName()] = $param->filter($response->getBody());
}

 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $value = $param->filter($value);
     if ($value instanceof PostFileInterface) {
         $request->addPostFile($value);
     } else {
         $request->addPostFile($param->getWireName(), $value);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $value = $param->filter($value);
     if ($param->getType() == 'object' && $param->getAdditionalProperties() instanceof Parameter) {
         $this->addPrefixedHeaders($request, $param, $value);
     } else {
         $request->setHeader($param->getWireName(), $value);
     }
 }

 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $value = $param->filter($value);
     $entityBody = EntityBody::factory($value);
     $request->setBody($entityBody);
     $this->addExpectHeader($request, $entityBody, $param->getData('expect_header'));
     if ($encoding = $entityBody->getContentEncoding()) {
         $request->setHeader('Content-Encoding', $encoding);
     }
 }

 /**
  * Map nested parameters into the location_key based parameters
  *
  * @param array     $value Value to map
  * @param Parameter $param Parameter that holds information about the current key
  *
  * @return array Returns the mapped array
  */
 protected function resolveRecursively(array $value, Parameter $param)
 {
     foreach ($value as $name => $v) {
         if ($subParam = $param->getProperty($name)) {
             $key = $subParam->getWireName();
             if (is_array($v)) {
                 $value[$key] = $this->resolveRecursively($v, $subParam);
             } elseif ($name != $key) {
                 $value[$key] = $param->filter($v);
                 unset($value[$name]);
             }
         }
     }
     return $value;
 }

 /**
  * Recursively process a parameter while applying filters
  *
  * @param Parameter $param API parameter being validated
  * @param mixed     $value Value to validate and process. The value may change during this process.
  */
 protected function recursiveProcess(Parameter $param, &$value)
 {
     if ($value === null) {
         return;
     }
     if (is_array($value)) {
         $type = $param->getType();
         if ($type == 'array') {
             foreach ($value as &$item) {
                 $this->recursiveProcess($param->getItems(), $item);
             }
         } elseif ($type == 'object' && !isset($value[0])) {
             // On the above line, we ensure that the array is associative and not numerically indexed
             $knownProperties = array();
             if ($properties = $param->getProperties()) {
                 foreach ($properties as $property) {
                     $name = $property->getName();
                     $key = $property->getWireName();
                     $knownProperties[$name] = 1;
                     if (isset($value[$key])) {
                         $this->recursiveProcess($property, $value[$key]);
                         if ($key != $name) {
                             $value[$name] = $value[$key];
                             unset($value[$key]);
                         }
                     }
                 }
             }
             // Remove any unknown and potentially unsafe properties
             if ($param->getAdditionalProperties() === false) {
                 $value = array_intersect_key($value, $knownProperties);
             } elseif (($additional = $param->getAdditionalProperties()) !== true) {
                 // Validate and filter additional properties
                 foreach ($value as &$v) {
                     $this->recursiveProcess($additional, $v);
                 }
             }
         }
     }
     $value = $param->filter($value);
 }

 protected function recursiveProcess(Parameter $param, &$value)
 {
     if ($value === null) {
         return;
     }
     if (is_array($value)) {
         $type = $param->getType();
         if ($type == 'array') {
             foreach ($value as &$item) {
                 $this->recursiveProcess($param->getItems(), $item);
             }
         } elseif ($type == 'object' && !isset($value[0])) {
             $knownProperties = array();
             if ($properties = $param->getProperties()) {
                 foreach ($properties as $property) {
                     $name = $property->getName();
                     $key = $property->getWireName();
                     $knownProperties[$name] = 1;
                     if (isset($value[$key])) {
                         $this->recursiveProcess($property, $value[$key]);
                         if ($key != $name) {
                             $value[$name] = $value[$key];
                             unset($value[$key]);
                         }
                     }
                 }
             }
             if ($param->getAdditionalProperties() === false) {
                 $value = array_intersect_key($value, $knownProperties);
             } elseif (($additional = $param->getAdditionalProperties()) !== true) {
                 foreach ($value as &$v) {
                     $this->recursiveProcess($additional, $v);
                 }
             }
         }
     }
     $value = $param->filter($value);
 }

 /**
  * {@inheritdoc}
  */
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $filteredValue = $param->filter($value);
     if (null !== $this->serializer && (is_object($filteredValue) || is_array($filteredValue))) {
         switch ($param->getSentAs()) {
             case 'json':
                 $request->setHeader('Content-Type', 'application/json');
                 $contentType = 'json';
                 break;
             case 'yml':
             case 'yaml':
                 $request->setHeader('Content-Type', 'application/yaml');
                 $contentType = 'yml';
                 break;
             default:
                 $request->setHeader('Content-Type', 'application/xml');
                 $contentType = 'xml';
                 break;
         }
         $context = SerializationContext::create();
         if (null !== ($groups = $param->getData('jms_serializer.groups'))) {
             $context->setGroups($groups);
         }
         if (null !== ($version = $param->getData('jms_serializer.version'))) {
             $context->setVersion($version);
         }
         if (null !== ($nulls = $param->getData('jms_serializer.serialize_nulls'))) {
             $context->setSerializeNull($nulls);
         }
         if (true === $param->getData('jms_serializer.max_depth_checks')) {
             $context->enableMaxDepthChecks();
         }
         $value = $this->serializer->serialize($filteredValue, $contentType, $context);
     }
     parent::visit($command, $request, $param, $value);
 }

 /**
  * Custom handling for arrays
  *
  * @param Parameter $param  Parameter for the object
  * @param array     $value  Value that is set for this parameter
  * @param string    $prefix Prefix for the resulting key
  * @param array     $query  Query string array passed by reference
  */
 protected function resolveArray(Parameter $param, array $value, $prefix, array &$query)
 {
     static $serializeEmpty = array('SetLoadBalancerPoliciesForBackendServer' => 1, 'SetLoadBalancerPoliciesOfListener' => 1, 'UpdateStack' => 1);
     // For BC, serialize empty lists for specific operations
     if (!$value) {
         if (isset($serializeEmpty[$this->fqname])) {
             $query[$prefix] = '';
         }
         return;
     }
     $offset = $param->getData('offset') ?: 1;
     foreach ($value as $index => $v) {
         $index += $offset;
         if (is_array($v) && ($items = $param->getItems())) {
             $this->customResolver($v, $items, $query, $prefix . '.' . $index);
         } else {
             $query[$prefix . '.' . $index] = $param->filter($v);
         }
     }
 }

 /**
  * @dataProvider dateTimeProvider
  */
 public function testAppliesFormat($d, $format, $result)
 {
     $p = new Parameter();
     $p->setFormat($format);
     $this->assertEquals($format, $p->getFormat());
     $this->assertEquals($result, $p->filter($d));
 }

 /**
  * Recursively build the XML body
  *
  * @param \SimpleXMLElement $xml   XML to modify
  * @param Parameter         $param API Parameter
  * @param mixed             $value Value to add
  */
 protected function addXml(\SimpleXMLElement $xml, Parameter $param, $value)
 {
     // Determine the name of the element
     $node = $param->getWireName();
     // Check if this property has a particular namespace
     $namespace = $param->getData('xmlNamespace');
     // Filter the value
     $value = $param->filter($value);
     if ($param->getType() == 'array') {
         $this->addXmlArray($xml, $param, $value, $namespace);
     } elseif ($param->getType() == 'object') {
         $this->addXmlObject($xml, $param, $value);
     } elseif ($param->getData('xmlAttribute')) {
         $xml->addAttribute($node, $value, $namespace);
     } else {
         $xml->addChild($node, $value, $namespace);
     }
 }

 /**
  * Recursively build the XML body
  *
  * @param \SimpleXMLElement $xml   XML to modify
  * @param Parameter         $param API Parameter
  * @param mixed             $value Value to add
  */
 protected function addXml(\SimpleXMLElement $xml, Parameter $param, $value)
 {
     if ($value === null) {
         return;
     }
     $value = $param->filter($value);
     $type = $param->getType();
     if ($type == 'object' || $type == 'array') {
         $ele = $param->getData('xmlFlattened') ? $xml : $xml->addChild($param->getWireName());
         if ($param->getType() == 'array') {
             $this->addXmlArray($ele, $param, $value, $param->getData('xmlNamespace'));
         } elseif ($param->getType() == 'object') {
             $this->addXmlObject($ele, $param, $value);
         }
     } elseif ($param->getData('xmlAttribute')) {
         $xml->addAttribute($param->getWireName(), $value, $param->getData('xmlNamespace'));
     } else {
         $xml->addChild($param->getWireName(), $value, $param->getData('xmlNamespace'));
     }
 }