Public Member Functions
	__construct ($filterRules, $validatorRules, array $data=null, array $options=null)

	addNamespace ($namespaces)

	addFilterPrefixPath ($prefix, $path)

	addValidatorPrefixPath ($prefix, $path)

	setPluginLoader (Zend_Loader_PluginLoader_Interface $loader, $type)

	getPluginLoader ($type)

	getMessages ()

	getErrors ()

	getInvalid ()

	getMissing ()

	getUnknown ()

	getEscaped ($fieldName=null)

	getUnescaped ($fieldName=null)

	__get ($fieldName)

	hasInvalid ()

	hasMissing ()

	hasUnknown ()

	hasValid ()

	isValid ($fieldName=null)

	__isset ($fieldName)

	process ()

	setData (array $data)

	setDefaultEscapeFilter ($escapeFilter)

	setOptions (array $options)

	setTranslator ($translator=null)

	getTranslator ()

	setDisableTranslator ($flag)

	translatorIsDisabled ()

Data Fields
const	ALLOW_EMPTY = 'allowEmpty'

const	BREAK_CHAIN = 'breakChainOnFailure'

const	DEFAULT_VALUE = 'default'

const	MESSAGES = 'messages'

const	ESCAPE_FILTER = 'escapeFilter'

const	FIELDS = 'fields'

const	FILTER = 'filter'

const	FILTER_CHAIN = 'filterChain'

const	MISSING_MESSAGE = 'missingMessage'

const	INPUT_NAMESPACE = 'inputNamespace'

const	VALIDATOR_NAMESPACE = 'validatorNamespace'

const	FILTER_NAMESPACE = 'filterNamespace'

const	NOT_EMPTY_MESSAGE = 'notEmptyMessage'

const	PRESENCE = 'presence'

const	PRESENCE_OPTIONAL = 'optional'

const	PRESENCE_REQUIRED = 'required'

const	RULE = 'rule'

const	RULE_WILDCARD = '*'

const	VALIDATE = 'validate'

const	VALIDATOR = 'validator'

const	VALIDATOR_CHAIN = 'validatorChain'

const	VALIDATOR_CHAIN_COUNT = 'validatorChainCount'

Protected Member Functions
	_escapeRecursive ($data)

	_filter ()

	_filterRule (array $filterRule)

	_getDefaultEscapeFilter ()

	_getMissingMessage ($rule, $field)

	_getNotEmptyMessage ($rule, $field)

	_process ()

	_validate ()

	_validateRule (array $validatorRule)

	_getNotEmptyValidatorInstance ($validatorRule)

	_getFilter ($classBaseName)

	_getValidator ($classBaseName)

	_getFilterOrValidator ($type, $classBaseName)

Protected Attributes
	$_data = array()

	$_filterRules = array()

	$_validatorRules = array()

	$_validFields = array()

	$_invalidMessages = array()

	$_invalidErrors = array()

	$_missingFields = array()

	$_unknownFields = array()

	$_defaultEscapeFilter = null

	$_loaders = array()

	$_defaults

	$_processed = false

	$_translator

	$_translatorDisabled = false

Detailed Description

Definition at line 43 of file Input.php.

Constructor & Destructor Documentation

◆ __construct()

__construct	(		$filterRules,
			$validatorRules,
		array	$data = `null`,
		array	$options = `null`
	)

Parameters

array	$filterRules
array	$validatorRules
array	$data	OPTIONAL
array	$options	OPTIONAL

Definition at line 165 of file Input.php.

     {
         if ($options) {
             $this->setOptions($options);
         }
 
         $this->_filterRules = (array) $filterRules;
         $this->_validatorRules = (array) $validatorRules;
 
         if ($data) {
             $this->setData($data);
         }
     }

Member Function Documentation

◆ __get()

__get ( $fieldName )

Parameters

string $fieldName

Returns: mixed

Definition at line 395 of file Input.php.

     {
         return $this->getEscaped($fieldName);
     }

◆ __isset()

__isset ( $fieldName )

Parameters

string $fieldName

Returns: boolean

Definition at line 453 of file Input.php.

     {
         $this->_process();
         return isset($this->_validFields[$fieldName]);
     }

◆ _escapeRecursive()

_escapeRecursive ( $data )

protected

Parameters

mixed $value

Returns: mixed

Definition at line 360 of file Input.php.

     {
         if($data === null) {
             return $data;
         }
 
         if (!is_array($data)) {
             return $this->_getDefaultEscapeFilter()->filter($data);
         }
         foreach ($data as &$element) {
             $element = $this->_escapeRecursive($element);
         }
         return $data;
     }

◆ _filter()

_filter ( )

protected

Returns: void

Make sure we have an array representing this filter chain. Don't typecast to (array) because it might be a Zend_Filter object

Filters are indexed by integer, metacommands are indexed by string. Pick out the filters.

Use defaults for filter metacommands.

Load all the filter classes and add them to the chain.

If the ruleName is the special wildcard rule, then apply the filter chain to all input data. Else just process the field named by the rule.

Definition at line 648 of file Input.php.

     {
         foreach ($this->_filterRules as $ruleName => &$filterRule) {
             if (!is_array($filterRule)) {
                 $filterRule = array($filterRule);
             }
 
             $filterList = array();
             foreach ($filterRule as $key => $value) {
                 if (is_int($key)) {
                     $filterList[] = $value;
                 }
             }
 
             $filterRule[self::RULE] = $ruleName;
             if (!isset($filterRule[self::FIELDS])) {
                 $filterRule[self::FIELDS] = $ruleName;
             }
 
             if (!isset($filterRule[self::FILTER_CHAIN])) {
                 $filterRule[self::FILTER_CHAIN] = new Zend_Filter();
                 foreach ($filterList as $filter) {
                     if (is_string($filter) || is_array($filter)) {
                         $filter = $this->_getFilter($filter);
                     }
                     $filterRule[self::FILTER_CHAIN]->addFilter($filter);
                 }
             }
 
             if ($ruleName == self::RULE_WILDCARD) {
                 foreach (array_keys($this->_data) as $field)  {
                     $this->_filterRule(array_merge($filterRule, array(self::FIELDS => $field)));
                 }
             } else {
                 $this->_filterRule($filterRule);
             }
         }
     }

◆ _filterRule()

_filterRule ( array $filterRule )

protected

Parameters

array $filterRule

Returns: void

Definition at line 710 of file Input.php.

     {
         $field = $filterRule[self::FIELDS];
         if (!array_key_exists($field, $this->_data)) {
             return;
         }
         if (is_array($this->_data[$field])) {
             foreach ($this->_data[$field] as $key => $value) {
                 $this->_data[$field][$key] = $filterRule[self::FILTER_CHAIN]->filter($value);
             }
         } else {
             $this->_data[$field] =
                 $filterRule[self::FILTER_CHAIN]->filter($this->_data[$field]);
         }
     }

◆ _getDefaultEscapeFilter()

_getDefaultEscapeFilter ( )

protected

Returns: Zend_Filter_Interface

Definition at line 729 of file Input.php.

     {
         if ($this->_defaultEscapeFilter !== null) {
             return $this->_defaultEscapeFilter;
         }
         return $this->setDefaultEscapeFilter($this->_defaults[self::ESCAPE_FILTER]);
     }

◆ _getFilter()

_getFilter ( $classBaseName )

protected

Parameters

mixed $classBaseName

Returns: Zend_Filter_Interface

Definition at line 1161 of file Input.php.

     {
         return $this->_getFilterOrValidator(self::FILTER, $classBaseName);
     }

◆ _getFilterOrValidator()

_getFilterOrValidator	(	$type,
		$classBaseName
	)

protected

Parameters

string	$type
mixed	$classBaseName

Returns: Zend_Filter_Interface|Zend_Validate_Interface

Exceptions

Zend_Filter_Exception

Definition at line 1181 of file Input.php.

     {
         $args = array();
 
         if (is_array($classBaseName)) {
             $args = $classBaseName;
             $classBaseName = array_shift($args);
         }
 
         $interfaceName = 'Zend_' . ucfirst($type) . '_Interface';
         $className = $this->getPluginLoader($type)->load(ucfirst($classBaseName));
 
         $class = new ReflectionClass($className);
 
         if (!$class->implementsInterface($interfaceName)) {
             #require_once 'Zend/Filter/Exception.php';
             throw new Zend_Filter_Exception("Class '$className' based on basename '$classBaseName' must implement the '$interfaceName' interface");
         }
 
         if ($class->hasMethod('__construct')) {
             $object = $class->newInstanceArgs($args);
         } else {
             $object = $class->newInstance();
         }
 
         return $object;
     }

◆ _getMissingMessage()

_getMissingMessage	(	$rule,
		$field
	)

protected

Parameters

string	$rule
string	$field

Returns: string

Definition at line 742 of file Input.php.

     {
         $message = $this->_defaults[self::MISSING_MESSAGE];
 
         if (null !== ($translator = $this->getTranslator())) {
             if ($translator->isTranslated(self::MISSING_MESSAGE)) {
                 $message = $translator->translate(self::MISSING_MESSAGE);
             } else {
                 $message = $translator->translate($message);
             }
         }
 
         $message = str_replace('%rule%', $rule, $message);
         $message = str_replace('%field%', $field, $message);
         return $message;
     }

◆ _getNotEmptyMessage()

_getNotEmptyMessage	(	$rule,
		$field
	)

protected

Returns: string

Definition at line 762 of file Input.php.

     {
         $message = $this->_defaults[self::NOT_EMPTY_MESSAGE];
 
         if (null !== ($translator = $this->getTranslator())) {
             if ($translator->isTranslated(self::NOT_EMPTY_MESSAGE)) {
                 $message = $translator->translate(self::NOT_EMPTY_MESSAGE);
             } else {
                 $message = $translator->translate($message);
             }
         }
 
         $message = str_replace('%rule%', $rule, $message);
         $message = str_replace('%field%', $field, $message);
         return $message;
     }

◆ _getNotEmptyValidatorInstance()

_getNotEmptyValidatorInstance ( $validatorRule )

protected

Check a validatorRule for the presence of a NotEmpty validator instance. The purpose is to preserve things like a custom message, that may have been set on the validator outside Zend_Filter_Input.

Parameters

array $validatorRule

Returns: mixed false if none is found, Zend_Validate_NotEmpty instance if found

Definition at line 1147 of file Input.php.

                                                                      {
         foreach ($validatorRule as $rule => $value) {
             if (is_object($value) and $value instanceof Zend_Validate_NotEmpty) {
                 return $value;
             }
         }
 
         return false;
     }

◆ _getValidator()

_getValidator ( $classBaseName )

protected

Parameters

mixed $classBaseName

Returns: Zend_Validate_Interface

Definition at line 1170 of file Input.php.

     {
         return $this->_getFilterOrValidator(self::VALIDATE, $classBaseName);
     }

◆ _process()

_process ( )

protected

Returns: void

Definition at line 782 of file Input.php.

     {
         if ($this->_processed === false) {
             $this->_filter();
             $this->_validate();
             $this->_processed = true;
         }
     }

◆ _validate()

_validate ( )

protected

Returns: void

Special case: if there are no validators, treat all fields as valid.

Make sure we have an array representing this validator chain. Don't typecast to (array) because it might be a Zend_Validate object

Validators are indexed by integer, metacommands are indexed by string. Pick out the validators.

Use defaults for validation metacommands.

Load all the validator classes and add them to the chain.

we are changing the defaults here, this is alright if all subsequent validators are also a not empty validator, but it goes wrong if one of them is not AND is required!!! that is why we restore the default value at the end of this loop

If the ruleName is the special wildcard rule, then apply the validator chain to all input data. Else just process the field named by the rule.

Unset fields in $_data that have been added to other arrays. We have to wait until all rules have been processed because a given field may be referenced by multiple rules.

Anything left over in $_data is an unknown field.

Definition at line 794 of file Input.php.

     {
         if (!$this->_validatorRules) {
             $this->_validFields = $this->_data;
             $this->_data = array();
             return;
         }
 
         // remember the default not empty message in case we want to temporarily change it
         $preserveDefaultNotEmptyMessage = $this->_defaults[self::NOT_EMPTY_MESSAGE];
 
         foreach ($this->_validatorRules as $ruleName => &$validatorRule) {
             if (!is_array($validatorRule)) {
                 $validatorRule = array($validatorRule);
             }
 
             $validatorList = array();
             foreach ($validatorRule as $key => $value) {
                 if (is_int($key)) {
                     $validatorList[$key] = $value;
                 }
             }
 
             $validatorRule[self::RULE] = $ruleName;
             if (!isset($validatorRule[self::FIELDS])) {
                 $validatorRule[self::FIELDS] = $ruleName;
             }
             if (!isset($validatorRule[self::BREAK_CHAIN])) {
                 $validatorRule[self::BREAK_CHAIN] = $this->_defaults[self::BREAK_CHAIN];
             }
             if (!isset($validatorRule[self::PRESENCE])) {
                 $validatorRule[self::PRESENCE] = $this->_defaults[self::PRESENCE];
             }
             if (!isset($validatorRule[self::ALLOW_EMPTY])) {
                 $foundNotEmptyValidator = false;
 
                 foreach ($validatorRule as $rule) {
                     if ($rule === 'NotEmpty') {
                         $foundNotEmptyValidator = true;
                         // field may not be empty, we are ready
                         break 1;
                     }
 
                     if (is_array($rule)) {
                         $keys      = array_keys($rule);
                         $classKey  = array_shift($keys);
                         if (isset($rule[$classKey])) {
                             $ruleClass = $rule[$classKey];
                             if ($ruleClass === 'NotEmpty') {
                                 $foundNotEmptyValidator = true;
                                 // field may not be empty, we are ready
                                 break 1;
                             }
                         }
                     }
 
                     // we must check if it is an object before using instanceof
                     if (!is_object($rule)) {
                         // it cannot be a NotEmpty validator, skip this one
                         continue;
                     }
 
                     if($rule instanceof Zend_Validate_NotEmpty) {
                         $foundNotEmptyValidator = true;
                         // field may not be empty, we are ready
                         break 1;
                     }
                 }
 
                 if (!$foundNotEmptyValidator) {
                     $validatorRule[self::ALLOW_EMPTY] = $this->_defaults[self::ALLOW_EMPTY];
                 } else {
                     $validatorRule[self::ALLOW_EMPTY] = false;
                 }
             }
 
             if (!isset($validatorRule[self::MESSAGES])) {
                 $validatorRule[self::MESSAGES] = array();
             } else if (!is_array($validatorRule[self::MESSAGES])) {
                 $validatorRule[self::MESSAGES] = array($validatorRule[self::MESSAGES]);
             } else if (array_intersect_key($validatorList, $validatorRule[self::MESSAGES])) {
                 // this seems pointless... it just re-adds what it already has...
                 // I can disable all this and not a single unit test fails...
                 // There are now corresponding numeric keys in the validation rule messages array
                 // Treat it as a named messages list for all rule validators
                 $unifiedMessages = $validatorRule[self::MESSAGES];
                 $validatorRule[self::MESSAGES] = array();
 
                 foreach ($validatorList as $key => $validator) {
                     if (array_key_exists($key, $unifiedMessages)) {
                         $validatorRule[self::MESSAGES][$key] = $unifiedMessages[$key];
                     }
                 }
             }
 
             if (!isset($validatorRule[self::VALIDATOR_CHAIN])) {
                 $validatorRule[self::VALIDATOR_CHAIN] = new Zend_Validate();
 
                 foreach ($validatorList as $key => $validator) {
                     if (is_string($validator) || is_array($validator)) {
                         $validator = $this->_getValidator($validator);
                     }
 
                     if (isset($validatorRule[self::MESSAGES][$key])) {
                         $value = $validatorRule[self::MESSAGES][$key];
                         if (is_array($value)) {
                             $validator->setMessages($value);
                         } else {
                             $validator->setMessage($value);
                         }
 
                         if ($validator instanceof Zend_Validate_NotEmpty) {
                             if (is_array($value)) {
                                 $temp = $value; // keep the original value
                                 $this->_defaults[self::NOT_EMPTY_MESSAGE] = array_pop($temp);
                                 unset($temp);
                             } else {
                                 $this->_defaults[self::NOT_EMPTY_MESSAGE] = $value;
                             }
                         }
                     }
 
                     $validatorRule[self::VALIDATOR_CHAIN]->addValidator($validator, $validatorRule[self::BREAK_CHAIN]);
                 }
                 $validatorRule[self::VALIDATOR_CHAIN_COUNT] = count($validatorList);
             }
 
             if ($ruleName == self::RULE_WILDCARD) {
                 foreach (array_keys($this->_data) as $field)  {
                     $this->_validateRule(array_merge($validatorRule, array(self::FIELDS => $field)));
                 }
             } else {
                 $this->_validateRule($validatorRule);
             }
 
             // reset the default not empty message
             $this->_defaults[self::NOT_EMPTY_MESSAGE] = $preserveDefaultNotEmptyMessage;
         }
 
 
 
         foreach (array_merge(array_keys($this->_missingFields), array_keys($this->_invalidMessages)) as $rule) {
             foreach ((array) $this->_validatorRules[$rule][self::FIELDS] as $field) {
                 unset($this->_data[$field]);
             }
         }
         foreach ($this->_validFields as $field => $value) {
             unset($this->_data[$field]);
         }
 
         $this->_unknownFields = $this->_data;
     }

◆ _validateRule()

_validateRule ( array $validatorRule )

protected

Parameters

array $validatorRule

Returns: void

Get one or more data values from input, and check for missing fields. Apply defaults if fields are missing.

Todo:: according to this code default value can't be an array. It has to be reviewed

If any required fields are missing, break the loop.

Evaluate the inputs against the validator chain.

If we got this far, the inputs for this rule pass validation.

Definition at line 985 of file Input.php.

     {
         $data = array();
         foreach ((array) $validatorRule[self::FIELDS] as $key => $field) {
             if (array_key_exists($field, $this->_data)) {
                 $data[$field] = $this->_data[$field];
             } else if (isset($validatorRule[self::DEFAULT_VALUE])) {
                 if (!is_array($validatorRule[self::DEFAULT_VALUE])) {
                     // Default value is a scalar
                     $data[$field] = $validatorRule[self::DEFAULT_VALUE];
                 } else {
                     // Default value is an array. Search for corresponding key
                     if (isset($validatorRule[self::DEFAULT_VALUE][$key])) {
                         $data[$field] = $validatorRule[self::DEFAULT_VALUE][$key];
                     } else if ($validatorRule[self::PRESENCE] == self::PRESENCE_REQUIRED) {
                         // Default value array is provided, but it doesn't have an entry for current field
                         // and presence is required
                         $this->_missingFields[$validatorRule[self::RULE]][] =
                            $this->_getMissingMessage($validatorRule[self::RULE], $field);
                     }
                 }
             } else if ($validatorRule[self::PRESENCE] == self::PRESENCE_REQUIRED) {
                 $this->_missingFields[$validatorRule[self::RULE]][] =
                     $this->_getMissingMessage($validatorRule[self::RULE], $field);
             }
         }
 
         if (isset($this->_missingFields[$validatorRule[self::RULE]]) && count($this->_missingFields[$validatorRule[self::RULE]]) > 0) {
             return;
         }
 
         if (count((array) $validatorRule[self::FIELDS]) > 1) {
             if (!$validatorRule[self::ALLOW_EMPTY]) {
                 $emptyFieldsFound = false;
                 $errorsList       = array();
                 $messages         = array();
 
                 foreach ($data as $fieldKey => $field) {
                     // if there is no Zend_Validate_NotEmpty instance in the rules, we will use the default
                     if (!($notEmptyValidator = $this->_getNotEmptyValidatorInstance($validatorRule))) {
                         $notEmptyValidator = $this->_getValidator('NotEmpty');
                         $notEmptyValidator->setMessage($this->_getNotEmptyMessage($validatorRule[self::RULE], $fieldKey));
                     }
 
                     if (!$notEmptyValidator->isValid($field)) {
                         foreach ($notEmptyValidator->getMessages() as $messageKey => $message) {
                             if (!isset($messages[$messageKey])) {
                                 $messages[$messageKey] = $message;
                             } else {
                                 $messages[] = $message;
                             }
                         }
                         $errorsList[] = $notEmptyValidator->getErrors();
                         $emptyFieldsFound = true;
                     }
                 }
 
                 if ($emptyFieldsFound) {
                     $this->_invalidMessages[$validatorRule[self::RULE]] = $messages;
                     $this->_invalidErrors[$validatorRule[self::RULE]]   = array_unique(call_user_func_array('array_merge', $errorsList));
                     return;
                 }
             }
 
             if (!$validatorRule[self::VALIDATOR_CHAIN]->isValid($data)) {
                 $this->_invalidMessages[$validatorRule[self::RULE]] = $validatorRule[self::VALIDATOR_CHAIN]->getMessages();
                 $this->_invalidErrors[$validatorRule[self::RULE]] = $validatorRule[self::VALIDATOR_CHAIN]->getErrors();
                 return;
             }
         } else if (count($data) > 0) {
             // $data is actually a one element array
             $fieldNames = array_keys($data);
             $fieldName = reset($fieldNames);
             $field     = reset($data);
 
             $failed = false;
             if (!is_array($field)) {
                 $field = array($field);
             }
 
             // if there is no Zend_Validate_NotEmpty instance in the rules, we will use the default
             if (!($notEmptyValidator = $this->_getNotEmptyValidatorInstance($validatorRule))) {
                 $notEmptyValidator = $this->_getValidator('NotEmpty');
                 $notEmptyValidator->setMessage($this->_getNotEmptyMessage($validatorRule[self::RULE], $fieldName));
             }
 
             if ($validatorRule[self::ALLOW_EMPTY]) {
                 $validatorChain = $validatorRule[self::VALIDATOR_CHAIN];
             } else {
                 $validatorChain = new Zend_Validate();
                 $validatorChain->addValidator($notEmptyValidator, true /* Always break on failure */);
                 $validatorChain->addValidator($validatorRule[self::VALIDATOR_CHAIN]);
             }
 
             foreach ($field as $key => $value) {
                 if ($validatorRule[self::ALLOW_EMPTY]  &&  !$notEmptyValidator->isValid($value)) {
                     // Field is empty AND it's allowed. Do nothing.
                     continue;
                 }
 
                 if (!$validatorChain->isValid($value)) {
                     if (isset($this->_invalidMessages[$validatorRule[self::RULE]])) {
                         $collectedMessages = $this->_invalidMessages[$validatorRule[self::RULE]];
                     } else {
                         $collectedMessages = array();
                     }
 
                     foreach ($validatorChain->getMessages() as $messageKey => $message) {
                         if (!isset($collectedMessages[$messageKey])) {
                             $collectedMessages[$messageKey] = $message;
                         } else {
                             $collectedMessages[] = $message;
                         }
                     }
 
                     $this->_invalidMessages[$validatorRule[self::RULE]] = $collectedMessages;
                     if (isset($this->_invalidErrors[$validatorRule[self::RULE]])) {
                         $this->_invalidErrors[$validatorRule[self::RULE]] = array_merge($this->_invalidErrors[$validatorRule[self::RULE]],
                                                                                         $validatorChain->getErrors());
                     } else {
                         $this->_invalidErrors[$validatorRule[self::RULE]] = $validatorChain->getErrors();
                     }
                     unset($this->_validFields[$fieldName]);
                     $failed = true;
                     if ($validatorRule[self::BREAK_CHAIN]) {
                         return;
                     }
                 }
             }
             if ($failed) {
                 return;
             }
         }
 
         foreach ((array) $validatorRule[self::FIELDS] as $field) {
             if (array_key_exists($field, $data)) {
                 $this->_validFields[$field] = $data[$field];
             }
         }
     }

◆ addFilterPrefixPath()

addFilterPrefixPath	(	$prefix,
		$path
	)

Add prefix path for all elements

Parameters

string	$prefix
string	$path

Returns: Zend_Filter_Input

Definition at line 207 of file Input.php.

     {
         $this->getPluginLoader(self::FILTER)->addPrefixPath($prefix, $path);
 
         return $this;
     }

◆ addNamespace()

addNamespace ( $namespaces )

Parameters

mixed $namespaces

Returns: Zend_Filter_Input

Deprecated:: since 1.5.0RC1 - use addFilterPrefixPath() or addValidatorPrefixPath instead.

Definition at line 184 of file Input.php.

     {
         if (!is_array($namespaces)) {
             $namespaces = array($namespaces);
         }
 
         foreach ($namespaces as $namespace) {
             $prefix = $namespace;
             $path = str_replace('_', DIRECTORY_SEPARATOR, $prefix);
             $this->addFilterPrefixPath($prefix, $path);
             $this->addValidatorPrefixPath($prefix, $path);
         }
 
         return $this;
     }

◆ addValidatorPrefixPath()

addValidatorPrefixPath	(	$prefix,
		$path
	)

Add prefix path for all elements

Parameters

string	$prefix
string	$path

Returns: Zend_Filter_Input

Definition at line 221 of file Input.php.

     {
         $this->getPluginLoader(self::VALIDATE)->addPrefixPath($prefix, $path);
 
         return $this;
     }

◆ getErrors()

getErrors ( )

Returns: array

Definition at line 305 of file Input.php.

     {
         $this->_process();
         return $this->_invalidErrors;
     }

◆ getEscaped()

getEscaped ( $fieldName = null )

Parameters

string $fieldName OPTIONAL

Returns: mixed

Definition at line 342 of file Input.php.

     {
         $this->_process();
         $this->_getDefaultEscapeFilter();
 
         if ($fieldName === null) {
             return $this->_escapeRecursive($this->_validFields);
         }
         if (array_key_exists($fieldName, $this->_validFields)) {
             return $this->_escapeRecursive($this->_validFields[$fieldName]);
         }
         return null;
     }

◆ getInvalid()

getInvalid ( )

Returns: array

Definition at line 314 of file Input.php.

     {
         $this->_process();
         return $this->_invalidMessages;
     }

◆ getMessages()

getMessages ( )

Returns: array

Definition at line 296 of file Input.php.

     {
         $this->_process();
         return array_merge($this->_invalidMessages, $this->_missingFields);
     }

◆ getMissing()

getMissing ( )

Returns: array

Definition at line 323 of file Input.php.

     {
         $this->_process();
         return $this->_missingFields;
     }

◆ getPluginLoader()

getPluginLoader ( $type )

Retrieve plugin loader for given type

$type may be one of:

filter
validator

If a plugin loader does not exist for the given type, defaults are created.

Parameters

string $type 'filter' or 'validate'

Returns: Zend_Loader_PluginLoader_Interface

Exceptions

Zend_Filter_Exception on invalid type

Definition at line 266 of file Input.php.

     {
         $type = strtolower($type);
         if (!isset($this->_loaders[$type])) {
             switch ($type) {
                 case self::FILTER:
                     $prefixSegment = 'Zend_Filter_';
                     $pathSegment   = 'Zend/Filter/';
                     break;
                 case self::VALIDATE:
                     $prefixSegment = 'Zend_Validate_';
                     $pathSegment   = 'Zend/Validate/';
                     break;
                 default:
                     #require_once 'Zend/Filter/Exception.php';
                     throw new Zend_Filter_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));
             }
 
             #require_once 'Zend/Loader/PluginLoader.php';
             $this->_loaders[$type] = new Zend_Loader_PluginLoader(
                 array($prefixSegment => $pathSegment)
             );
         }
 
         return $this->_loaders[$type];
     }

◆ getTranslator()

getTranslator ( )

Return translation object

Returns: Zend_Translate_Adapter|null

Definition at line 598 of file Input.php.

     {
         if ($this->translatorIsDisabled()) {
             return null;
         }
 
         if ($this->_translator === null) {
             #require_once 'Zend/Registry.php';
             if (Zend_Registry::isRegistered('Zend_Translate')) {
                 $translator = Zend_Registry::get('Zend_Translate');
                 if ($translator instanceof Zend_Translate_Adapter) {
                     return $translator;
                 } elseif ($translator instanceof Zend_Translate) {
                     return $translator->getAdapter();
                 }
             }
         }
 
         return $this->_translator;
     }

◆ getUnescaped()

getUnescaped ( $fieldName = null )

Parameters

string $fieldName OPTIONAL

Returns: mixed

Definition at line 379 of file Input.php.

     {
         $this->_process();
         if ($fieldName === null) {
             return $this->_validFields;
         }
         if (array_key_exists($fieldName, $this->_validFields)) {
             return $this->_validFields[$fieldName];
         }
         return null;
     }

◆ getUnknown()

getUnknown ( )

Returns: array

Definition at line 332 of file Input.php.

     {
         $this->_process();
         return $this->_unknownFields;
     }

◆ hasInvalid()

hasInvalid ( )

Returns: boolean

Definition at line 403 of file Input.php.

     {
         $this->_process();
         return !(empty($this->_invalidMessages));
     }

◆ hasMissing()

hasMissing ( )

Returns: boolean

Definition at line 412 of file Input.php.

     {
         $this->_process();
         return !(empty($this->_missingFields));
     }

◆ hasUnknown()

hasUnknown ( )

Returns: boolean

Definition at line 421 of file Input.php.

     {
         $this->_process();
         return !(empty($this->_unknownFields));
     }

◆ hasValid()

hasValid ( )

Returns: boolean

Definition at line 430 of file Input.php.

     {
         $this->_process();
         return !(empty($this->_validFields));
     }

◆ isValid()

isValid ( $fieldName = null )

Parameters

string $fieldName

Returns: boolean

Definition at line 440 of file Input.php.

     {
         $this->_process();
         if ($fieldName === null) {
             return !($this->hasMissing() || $this->hasInvalid());
         }
         return array_key_exists($fieldName, $this->_validFields);
     }

◆ process()

process ( )

Returns: Zend_Filter_Input

Exceptions

Zend_Filter_Exception

Definition at line 463 of file Input.php.

     {
         $this->_process();
         if ($this->hasInvalid()) {
             #require_once 'Zend/Filter/Exception.php';
             throw new Zend_Filter_Exception("Input has invalid fields");
         }
         if ($this->hasMissing()) {
             #require_once 'Zend/Filter/Exception.php';
             throw new Zend_Filter_Exception("Input has missing fields");
         }
 
         return $this;
     }

◆ setData()

setData ( array $data )

Parameters

array $data

Returns: Zend_Filter_Input

Reset to initial state

Definition at line 482 of file Input.php.

     {
         $this->_data = $data;
 
         $this->_validFields = array();
         $this->_invalidMessages = array();
         $this->_invalidErrors = array();
         $this->_missingFields = array();
         $this->_unknownFields = array();
 
         $this->_processed = false;
 
         return $this;
     }

◆ setDefaultEscapeFilter()

setDefaultEscapeFilter ( $escapeFilter )

Parameters

mixed $escapeFilter

Returns: Zend_Filter_Interface

Definition at line 504 of file Input.php.

     {
         if (is_string($escapeFilter) || is_array($escapeFilter)) {
             $escapeFilter = $this->_getFilter($escapeFilter);
         }
         if (!$escapeFilter instanceof Zend_Filter_Interface) {
             #require_once 'Zend/Filter/Exception.php';
             throw new Zend_Filter_Exception('Escape filter specified does not implement Zend_Filter_Interface');
         }
         $this->_defaultEscapeFilter = $escapeFilter;
         return $escapeFilter;
     }

◆ setDisableTranslator()

setDisableTranslator ( $flag )

Indicate whether or not translation should be disabled

Parameters

bool $flag

Returns: Zend_Filter_Input

Definition at line 625 of file Input.php.

     {
         $this->_translatorDisabled = (bool) $flag;
         return $this;
     }

◆ setOptions()

setOptions ( array $options )

Parameters

array $options

Returns: Zend_Filter_Input

Exceptions

Zend_Filter_Exception if an unknown option is given

Definition at line 522 of file Input.php.

     {
         foreach ($options as $option => $value) {
             switch ($option) {
                 case self::ESCAPE_FILTER:
                     $this->setDefaultEscapeFilter($value);
                     break;
                 case self::INPUT_NAMESPACE:
                     $this->addNamespace($value);
                     break;
                 case self::VALIDATOR_NAMESPACE:
                     if(is_string($value)) {
                         $value = array($value);
                     }
 
                     foreach($value AS $prefix) {
                         $this->addValidatorPrefixPath(
                                 $prefix,
                                 str_replace('_', DIRECTORY_SEPARATOR, $prefix)
                         );
                     }
                     break;
                 case self::FILTER_NAMESPACE:
                     if(is_string($value)) {
                         $value = array($value);
                     }
 
                     foreach($value AS $prefix) {
                         $this->addFilterPrefixPath(
                                 $prefix,
                                 str_replace('_', DIRECTORY_SEPARATOR, $prefix)
                         );
                     }
                     break;
                 case self::ALLOW_EMPTY:
                 case self::BREAK_CHAIN:
                 case self::MISSING_MESSAGE:
                 case self::NOT_EMPTY_MESSAGE:
                 case self::PRESENCE:
                     $this->_defaults[$option] = $value;
                     break;
                 default:
                     #require_once 'Zend/Filter/Exception.php';
                     throw new Zend_Filter_Exception("Unknown option '$option'");
                     break;
             }
         }
 
         return $this;
     }

◆ setPluginLoader()

setPluginLoader	(	Zend_Loader_PluginLoader_Interface	$loader,
			$type
	)

Set plugin loaders for use with decorators and elements

Parameters

Zend_Loader_PluginLoader_Interface	$loader
string	$type	'filter' or 'validate'

Returns: Zend_Filter_Input

Exceptions

Zend_Filter_Exception on invalid type

Definition at line 236 of file Input.php.

     {
         $type = strtolower($type);
         switch ($type) {
             case self::FILTER:
             case self::VALIDATE:
                 $this->_loaders[$type] = $loader;
                 return $this;
             default:
                 #require_once 'Zend/Filter/Exception.php';
                 throw new Zend_Filter_Exception(sprintf('Invalid type "%s" provided to setPluginLoader()', $type));
         }
 
         return $this;
     }

◆ setTranslator()

setTranslator ( $translator = null )

Set translation object

Parameters

Zend_Translate | Zend_Translate_Adapter | null $translator

Returns: Zend_Filter_Input

Definition at line 579 of file Input.php.

     {
         if ((null === $translator) || ($translator instanceof Zend_Translate_Adapter)) {
             $this->_translator = $translator;
         } elseif ($translator instanceof Zend_Translate) {
             $this->_translator = $translator->getAdapter();
         } else {
             #require_once 'Zend/Validate/Exception.php';
             throw new Zend_Validate_Exception('Invalid translator specified');
         }
 
         return $this;
     }

◆ translatorIsDisabled()

translatorIsDisabled ( )

Is translation disabled?

Returns: bool

Definition at line 636 of file Input.php.

     {
         return $this->_translatorDisabled;
     }

Field Documentation

◆ $_data

$_data = array()

protected

Definition at line 72 of file Input.php.

◆ $_defaultEscapeFilter

$_defaultEscapeFilter = null

protected

Definition at line 121 of file Input.php.

◆ $_defaults

$_defaults

protected

Initial value:

= array(
        self::ALLOW_EMPTY         => false,
        self::BREAK_CHAIN         => false,
        self::ESCAPE_FILTER       => 'HtmlEntities',
        self::MISSING_MESSAGE     => "Field '%field%' is required by rule '%rule%', but the field is missing",
        self::NOT_EMPTY_MESSAGE   => "You must give a non-empty value for field '%field%'",
        self::PRESENCE            => self::PRESENCE_OPTIONAL
    )

Definition at line 132 of file Input.php.

◆ $_filterRules

$_filterRules = array()

protected

Definition at line 77 of file Input.php.

◆ $_invalidErrors

$_invalidErrors = array()

protected

Definition at line 102 of file Input.php.

◆ $_invalidMessages

$_invalidMessages = array()

protected

Definition at line 95 of file Input.php.

◆ $_loaders

$_loaders = array()

protected

Definition at line 127 of file Input.php.

◆ $_missingFields

$_missingFields = array()

protected

Definition at line 109 of file Input.php.

◆ $_processed

$_processed = false

protected

Definition at line 145 of file Input.php.

◆ $_translator

$_translator

protected

Definition at line 151 of file Input.php.

◆ $_translatorDisabled

$_translatorDisabled = false

protected

Definition at line 157 of file Input.php.

◆ $_unknownFields

$_unknownFields = array()

protected

Definition at line 115 of file Input.php.

◆ $_validatorRules

$_validatorRules = array()

protected

Definition at line 82 of file Input.php.

◆ $_validFields

$_validFields = array()

protected

Definition at line 88 of file Input.php.

◆ ALLOW_EMPTY

const ALLOW_EMPTY = 'allowEmpty'

Definition at line 46 of file Input.php.

◆ BREAK_CHAIN

const BREAK_CHAIN = 'breakChainOnFailure'

Definition at line 47 of file Input.php.

◆ DEFAULT_VALUE

const DEFAULT_VALUE = 'default'

Definition at line 48 of file Input.php.

◆ ESCAPE_FILTER

const ESCAPE_FILTER = 'escapeFilter'

Definition at line 50 of file Input.php.

◆ FIELDS

const FIELDS = 'fields'

Definition at line 51 of file Input.php.

◆ FILTER

const FILTER = 'filter'

Definition at line 52 of file Input.php.

◆ FILTER_CHAIN

const FILTER_CHAIN = 'filterChain'

Definition at line 53 of file Input.php.

◆ FILTER_NAMESPACE

const FILTER_NAMESPACE = 'filterNamespace'

Definition at line 57 of file Input.php.

◆ INPUT_NAMESPACE

const INPUT_NAMESPACE = 'inputNamespace'

Definition at line 55 of file Input.php.

◆ MESSAGES

const MESSAGES = 'messages'

Definition at line 49 of file Input.php.

◆ MISSING_MESSAGE

const MISSING_MESSAGE = 'missingMessage'

Definition at line 54 of file Input.php.

◆ NOT_EMPTY_MESSAGE

const NOT_EMPTY_MESSAGE = 'notEmptyMessage'

Definition at line 58 of file Input.php.

◆ PRESENCE

const PRESENCE = 'presence'

Definition at line 59 of file Input.php.

◆ PRESENCE_OPTIONAL

const PRESENCE_OPTIONAL = 'optional'

Definition at line 60 of file Input.php.

◆ PRESENCE_REQUIRED

const PRESENCE_REQUIRED = 'required'

Definition at line 61 of file Input.php.

◆ RULE

const RULE = 'rule'

Definition at line 62 of file Input.php.

◆ RULE_WILDCARD

const RULE_WILDCARD = '*'

Definition at line 63 of file Input.php.

◆ VALIDATE

const VALIDATE = 'validate'

Definition at line 64 of file Input.php.

◆ VALIDATOR

const VALIDATOR = 'validator'

Definition at line 65 of file Input.php.

◆ VALIDATOR_CHAIN

const VALIDATOR_CHAIN = 'validatorChain'

Definition at line 66 of file Input.php.

◆ VALIDATOR_CHAIN_COUNT

const VALIDATOR_CHAIN_COUNT = 'validatorChainCount'

Definition at line 67 of file Input.php.

◆ VALIDATOR_NAMESPACE

const VALIDATOR_NAMESPACE = 'validatorNamespace'

Definition at line 56 of file Input.php.

The documentation for this class was generated from the following file:

vendor/magento/zendframework1/library/Zend/Filter/Input.php

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ __get()

◆ __isset()

◆ _escapeRecursive()

◆ _filter()

◆ _filterRule()

◆ _getDefaultEscapeFilter()

◆ _getFilter()

◆ _getFilterOrValidator()

◆ _getMissingMessage()

◆ _getNotEmptyMessage()

◆ _getNotEmptyValidatorInstance()

◆ _getValidator()

◆ _process()

◆ _validate()

◆ _validateRule()

◆ addFilterPrefixPath()

◆ addNamespace()

◆ addValidatorPrefixPath()

◆ getErrors()

◆ getEscaped()

◆ getInvalid()

◆ getMessages()

◆ getMissing()

◆ getPluginLoader()

◆ getTranslator()

◆ getUnescaped()

◆ getUnknown()

◆ hasInvalid()

◆ hasMissing()

◆ hasUnknown()

◆ hasValid()

◆ isValid()

◆ process()

◆ setData()

◆ setDefaultEscapeFilter()

◆ setDisableTranslator()

◆ setOptions()

◆ setPluginLoader()

◆ setTranslator()

◆ translatorIsDisabled()

Field Documentation

◆ $_data

◆ $_defaultEscapeFilter

◆ $_defaults

◆ $_filterRules

◆ $_invalidErrors

◆ $_invalidMessages

◆ $_loaders

◆ $_missingFields

◆ $_processed

◆ $_translator

◆ $_translatorDisabled

◆ $_unknownFields

◆ $_validatorRules

◆ $_validFields

◆ ALLOW_EMPTY

◆ BREAK_CHAIN

◆ DEFAULT_VALUE

◆ ESCAPE_FILTER

◆ FIELDS

◆ FILTER

◆ FILTER_CHAIN

◆ FILTER_NAMESPACE

◆ INPUT_NAMESPACE

◆ MESSAGES

◆ MISSING_MESSAGE

◆ NOT_EMPTY_MESSAGE

◆ PRESENCE

◆ PRESENCE_OPTIONAL

◆ PRESENCE_REQUIRED

◆ RULE

◆ RULE_WILDCARD