PHP Parameter::getName方法代码示例

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

 /**
  * Validates an array of tags or aliases (just strings)
  *
  * @param array     $aliases
  * @param Parameter $parameter
  *
  * @return array
  * @throws \Guzzle\Service\Exception\ValidationException
  */
 public static function tagsOrAliases(array $aliases, Parameter $parameter)
 {
     foreach ($aliases as $alias) {
         if (!is_string($alias) || strlen($alias) > 128) {
             throw new ValidationException("Invalid value [{$alias}] in {$parameter->getName()}");
         }
     }
     return $aliases;
 }

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

 protected function processXmlAttribute(Parameter $property, array &$value)
 {
     $sentAs = $property->getWireName();
     if (isset($value['@attributes'][$sentAs])) {
         $value[$property->getName()] = $value['@attributes'][$sentAs];
         unset($value['@attributes'][$sentAs]);
         if (empty($value['@attributes'])) {
             unset($value['@attributes']);
         }
     }
 }

 public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null)
 {
     $name = $param->getName();
     $key = $param->getWireName();
     if (isset($value[$key])) {
         $this->recursiveProcess($param, $value[$key]);
         if ($key != $name) {
             $value[$name] = $value[$key];
             unset($value[$key]);
         }
     }
 }

 protected function processPrefixedHeaders(Response $response, Parameter $param, &$value)
 {
     if ($prefix = $param->getSentAs()) {
         $container = $param->getName();
         $len = strlen($prefix);
         foreach ($response->getHeaders()->toArray() as $key => $header) {
             if (stripos($key, $prefix) === 0) {
                 $value[$container][substr($key, $len)] = count($header) == 1 ? end($header) : $header;
             }
         }
     }
 }

 /**
  * Process a prefixed header array
  *
  * @param Response  $response Response that contains the headers
  * @param Parameter $param    Parameter object
  * @param array     $value    Value response array to modify
  */
 protected function processPrefixedHeaders(Response $response, Parameter $param, &$value)
 {
     // Grab prefixed headers that should be placed into an array with the prefix stripped
     if ($prefix = $param->getSentAs()) {
         $container = $param->getName();
         $len = strlen($prefix);
         // Find all matching headers and place them into the containing element
         foreach ($response->getHeaders() as $key => $header) {
             if (stripos($key, $prefix) === 0) {
                 // Account for multi-value headers
                 $value[$container][substr($key, $len)] = count($header) == 1 ? end($header) : $header;
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null)
 {
     $sentAs = $param->getWireName();
     $name = $param->getName();
     if (isset($value[$sentAs])) {
         $this->recursiveProcess($param, $value[$sentAs]);
         if ($name != $sentAs) {
             $value[$name] = $value[$sentAs];
             unset($value[$sentAs]);
         }
     } elseif ($param->getType() == 'array') {
         // Use a default array when the value is missing
         $value[$name] = array();
     } elseif ($param->getType() == 'boolean') {
         // Use a default value of false when the value is missing
         $value[$name] = false;
     }
 }

 /**
  * Add a parameter to the command
  *
  * @param Parameter $param Parameter to add
  *
  * @return self
  */
 public function addParam(Parameter $param)
 {
     $this->parameters[$param->getName()] = $param;
     $param->setParent($this);
     return $this;
 }

 /**
  * Recursively validate a parameter
  *
  * @param Parameter $param  API parameter being validated
  * @param mixed     $value  Value to validate and validate. The value may change during this validate.
  * @param string    $path   Current validation path (used for error reporting)
  * @param int       $depth  Current depth in the validation validate
  *
  * @return bool Returns true if valid, or false if invalid
  */
 protected function recursiveProcess(Parameter $param, &$value, $path = '', $depth = 0)
 {
     // Update the value by adding default or static values
     $value = $param->getValue($value);
     $required = $param->getRequired();
     // if the value is null and the parameter is not required or is static, then skip any further recursion
     if (null === $value && !$required || $param->getStatic()) {
         return true;
     }
     $type = $param->getType();
     // Attempt to limit the number of times is_array is called by tracking if the value is an array
     $valueIsArray = is_array($value);
     // If a name is set then update the path so that validation messages are more helpful
     if ($name = $param->getName()) {
         $path .= "[{$name}]";
     }
     if ($type == 'object') {
         // Objects are either associative arrays, ToArrayInterface, or some other object
         if ($param->getInstanceOf()) {
             $instance = $param->getInstanceOf();
             if (!$value instanceof $instance) {
                 $this->errors[] = "{$path} must be an instance of {$instance}";
                 return false;
             }
         }
         // Determine whether or not this "value" has properties and should be traversed
         $traverse = $temporaryValue = false;
         // Convert the value to an array
         if (!$valueIsArray && $value instanceof ToArrayInterface) {
             $value = $value->toArray();
         }
         if ($valueIsArray) {
             // Ensure that the array is associative and not numerically indexed
             if (isset($value[0])) {
                 $this->errors[] = "{$path} must be an array of properties. Got a numerically indexed array.";
                 return false;
             }
             $traverse = true;
         } elseif ($value === null) {
             // Attempt to let the contents be built up by default values if possible
             $value = array();
             $temporaryValue = $valueIsArray = $traverse = true;
         }
         if ($traverse) {
             if ($properties = $param->getProperties()) {
                 // if properties were found, the validate each property of the value
                 foreach ($properties as $property) {
                     $name = $property->getName();
                     if (isset($value[$name])) {
                         $this->recursiveProcess($property, $value[$name], $path, $depth + 1);
                     } else {
                         $current = null;
                         $this->recursiveProcess($property, $current, $path, $depth + 1);
                         // Only set the value if it was populated with something
                         if (null !== $current) {
                             $value[$name] = $current;
                         }
                     }
                 }
             }
             $additional = $param->getAdditionalProperties();
             if ($additional !== true) {
                 // If additional properties were found, then validate each against the additionalProperties attr.
                 $keys = array_keys($value);
                 // Determine the keys that were specified that were not listed in the properties of the schema
                 $diff = array_diff($keys, array_keys($properties));
                 if (!empty($diff)) {
                     // Determine which keys are not in the properties
                     if ($additional instanceof Parameter) {
                         foreach ($diff as $key) {
                             $this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth);
                         }
                     } else {
                         // if additionalProperties is set to false and there are additionalProperties in the values, then fail
                         foreach ($diff as $prop) {
                             $this->errors[] = sprintf('%s[%s] is not an allowed property', $path, $prop);
                         }
                     }
                 }
             }
             // A temporary value will be used to traverse elements that have no corresponding input value.
             // This allows nested required parameters with default values to bubble up into the input.
             // Here we check if we used a temp value and nothing bubbled up, then we need to remote the value.
             if ($temporaryValue && empty($value)) {
                 $value = null;
                 $valueIsArray = false;
             }
         }
     } elseif ($type == 'array' && $valueIsArray && $param->getItems()) {
         foreach ($value as $i => &$item) {
//.........这里部分代码省略.........

 /**
  * Prepares and stores the value for a link
  *
  * Creates an link object (with "class" and "href") from the Guzzle
  * Parameter describing the link, and the value provided by the
  * user.
  *
  * @param \Guzzle\Service\Command\CommandInterface $command
  * @param \Guzzle\Service\Description\Parameter    $parameter
  * @param mixed                                   $value
  */
 public function addLinkValue(CommandInterface $command, Parameter $parameter, $value)
 {
     $values = array();
     if (isset($this->values[$command])) {
         $values = $this->values[$command];
     }
     $values[$parameter->getName()] = array('class' => $parameter->getData('class'), 'href' => preg_replace('/{value}/', $parameter->getValue($value), $parameter->getData('href')));
     $this->values[$command] = $values;
 }

 /**
  * Add a property to the parameter
  *
  * @param Parameter $property Properties to set
  *
  * @return self
  */
 public function addProperty(Parameter $property)
 {
     $this->properties[$property->getName()] = $property;
     $property->setParent($this);
     $this->propertiesCache = null;
     return $this;
 }

 /**
  * Add a model to the service description
  *
  * @param Parameter $model Model to add
  *
  * @return self
  */
 public function addModel(Parameter $model)
 {
     $this->models[$model->getName()] = $model;
     return $this;
 }

protected function recursiveProcess(Parameter $param, &$value, $path = '', $depth = 0)
{

 $value = $param->getValue($value);

$required = $param->getRequired();

 if ((null === $value && !$required) || $param->getStatic()) {
return true;
}

$type = $param->getType();

 $valueIsArray = is_array($value);

 if ($name = $param->getName()) {
$path .= "[{$name}]";
}

if ($type == 'object') {


 if ($param->getInstanceOf()) {
$instance = $param->getInstanceOf();
if (!($value instanceof $instance)) {
$this->errors[] = "{$path} must be an instance of {$instance}";
return false;
}
}


 $traverse = $temporaryValue = false;


 if (!$valueIsArray && $value instanceof ToArrayInterface) {
$value = $value->toArray();
}

if ($valueIsArray) {

 if (isset($value[0])) {
$this->errors[] = "{$path} must be an array of properties. Got a numerically indexed array.";
return false;
}
$traverse = true;
} elseif ($value === null) {

 $value = array();
$temporaryValue = $valueIsArray = $traverse = true;
}

if ($traverse) {

if ($properties = $param->getProperties()) {

 foreach ($properties as $property) {
$name = $property->getName();
if (isset($value[$name])) {
$this->recursiveProcess($property, $value[$name], $path, $depth + 1);
} else {
$current = null;
$this->recursiveProcess($property, $current, $path, $depth + 1);

 if (null !== $current) {
$value[$name] = $current;
}
}
}
}

$additional = $param->getAdditionalProperties();
if ($additional !== true) {

 $keys = array_keys($value);

 $diff = array_diff($keys, array_keys($properties));
if (!empty($diff)) {

 if ($additional instanceOf Parameter) {
foreach ($diff as $key) {
$this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth);
}
} else {

 $keys = array_keys($value);
$this->errors[] = sprintf('%s[%s] is not an allowed property', $path, reset($keys));
}
}
}


 
 
 if ($temporaryValue && empty($value)) {
$value = null;
$valueIsArray = false;
}
}

} elseif ($type == 'array' && $valueIsArray && $param->getItems()) {
//.........这里部分代码省略.........

 public function testCanBuildUpParams()
 {
     $p = new Parameter(array());
     $p->setName('foo')->setDescription('c')->setFilters(array('d'))->setLocation('e')->setSentAs('f')->setMaxLength(1)->setMinLength(1)->setMinimum(2)->setMaximum(2)->setMinItems(3)->setMaxItems(3)->setRequired(true)->setStatic(true)->setDefault('h')->setType('i');
     $p->addFilter('foo');
     $this->assertEquals('foo', $p->getName());
     $this->assertEquals('h', $p->getDefault());
     $this->assertEquals('c', $p->getDescription());
     $this->assertEquals(array('d', 'foo'), $p->getFilters());
     $this->assertEquals('e', $p->getLocation());
     $this->assertEquals('f', $p->getSentAs());
     $this->assertEquals(1, $p->getMaxLength());
     $this->assertEquals(1, $p->getMinLength());
     $this->assertEquals(2, $p->getMaximum());
     $this->assertEquals(2, $p->getMinimum());
     $this->assertEquals(3, $p->getMaxItems());
     $this->assertEquals(3, $p->getMinItems());
     $this->assertEquals(true, $p->getRequired());
     $this->assertEquals(true, $p->getStatic());
     $this->assertEquals('i', $p->getType());
 }