/**
	 * This function routes all requests to the validation methods.
	 *
	 * If validation method does not exist false will be returned.
	 *
	 * Optional elements will be checked before executing the validation callback.
	 * The following values are considered as empty: false, null and an empty string or array.
	 *
	 * The arguments array has to be in the following order:
	 * The First argument should be the optional state, the second state the value followed by the
	 * arguments for the calles function.
	 *
	 * @see empty()
	 * @param string Function name
	 * @param array Arguments for the function
	 */
	public static function __callStatic($name, $arguments) {
		self::$errors = array();

		if ($name[0] == '_') {
			$name = substr($name, 1);
		}
		// Use Late static binding because __CLASS__ would contain AbstractValidator
		if (method_exists(get_called_class(), $name) == true) {
			// Optional check
			if ($arguments[1] == true && ($arguments[0] === false || $arguments[0] === null || $arguments[0] === '' || $arguments[0] === array())) {
				return true;
			}
			return call_user_func_array("static::{$name}", $arguments);
		}
		else {
			return false;
		}
	}

 /**
  * @test
  */
 public function testNumbers()
 {
     foreach ($this->getValidNumbers() as $number) {
         $this->assertTrue($this->validator->isValid($number));
     }
     foreach ($this->getInvalidNumbers() as $number) {
         $this->assertFalse($this->validator->isValid($number));
     }
 }

 /**
  * @param string $name
  * @param string  $value
  * @param bool   $stopOnError
  *
  * @return bool
  */
 public function validate($name, $value, $stopOnError = false)
 {
     $this->errors = [];
     if (null === $this->validator) {
         $this->validator = ValidatorFactory::create($name, $this->type, $this->rules);
     }
     $isValid = $this->validator->validate($value, $stopOnError);
     if (false === $isValid) {
         $this->errors = $this->validator->getErrors();
     }
     return $isValid;
 }

 public function init()
 {
     if ($this->enableIDN && !function_exists('idn_to_ascii')) {
         $this->addError($this->intlErrorMessage);
     }
     parent::init();
 }

 /**
  * Do our own constructor so we can check for the php-clamav library
  * @param \Foundation\Form\Element $e the element we are validating
  * @param integer $sizeInBytes
  */
 public function __construct(\Foundation\Form\Element $element)
 {
     if (!extension_loaded('clamav') or !function_exists('cl_scanfile')) {
         throw new \Foundation\Exception("Virusscan validator requires the php-clamav extension.");
     }
     parent::__construct($element);
 }

 /**
  * Construct 
  * Check the ruleSet
  * @param \Foundation\Form\Element $e
  * @param mixed $ruleSet
  */
 public function __construct(\Foundation\Form\Element $e, $ruleSet)
 {
     if (!\is_array($ruleSet) or !isset($ruleSet[0]) or !isset($ruleSet[1])) {
         throw new \Foundation\Exception("The ruleset for NumberRange must be an array with two elements.");
     }
     parent::__construct($e, $ruleSet);
 }

 /**
  * @param null $options - expects to find a ['token'] entry in
  * options, with the token in it
  */
 public function __construct($options = null)
 {
     parent::__construct($options);
     $this->setMessage(self::MsgInvalidToken, 'Unable to authenticate form data. Please refresh and try again.');
     $this->token = isset($options['token']) ? $options['token'] : 'missing token';
     $this->logger = isset($options['logger']) ? $options['logger'] : null;
 }

 /**
  * Constructor
  *
  * @param array|callable $options
  */
 public function __construct($options = null)
 {
     if (is_callable($options)) {
         $options = ['callback' => $options];
     }
     parent::__construct($options);
 }

 public function init()
 {
     if ($this->message === null) {
         switch ($this->operator) {
             case '==':
                 $this->message = '{compareAttribute} must be repeated exactly.';
                 break;
             case '===':
                 $this->message = '{compareAttribute} must be repeated exactly.';
                 break;
             case '!=':
                 $this->message = '{compareAttribute} must not be equal to "{compareValue}".';
                 break;
             case '!==':
                 $this->message = '{compareAttribute} must not be equal to "{compareValue}".';
                 break;
             case '>':
                 $this->message = '{compareAttribute} must be greater than "{compareValue}".';
                 break;
             case '>=':
                 $this->message = '{compareAttribute} must be greater than or equal to "{compareValue}".';
                 break;
             case '<':
                 $this->message = '{compareAttribute} must be less than "{compareValue}".';
                 break;
             case '<=':
                 $this->message = '{compareAttribute} must be less than or equal to "{compareValue}".';
                 break;
             default:
                 $this->addError('Unknown operator: {operator}', ['{operator}' => $this->operator]);
         }
     }
     parent::init();
 }

 /**
  * Construct 
  * Check the ruleSet
  * @param \Foundation\Form\Element $e
  * @param mixed $ruleSet
  */
 public function __construct(\Foundation\Form\Element $e, $ruleSet)
 {
     if (!\is_int($ruleSet)) {
         throw new \Foundation\Exception("The ruleset for MaximumLength must be an integer");
     }
     parent::__construct($e, $ruleSet);
 }

 /**
  * {@inheritdoc}
  */
 public function sanitize()
 {
     if ($this->canSanitize()) {
         return new \DateTime($this->getInput());
     }
     return parent::sanitize();
 }

 public function init()
 {
     if (!is_array($this->range)) {
         throw new \InvalidArgumentException($this->rangeErrorMessage);
     }
     parent::init();
 }

 /**
  * Construct 
  * Check the ruleSet
  * 
  * @param \Foundation\Form\Element $e
  * @param mixed $ruleSet
  */
 public function __construct(\Foundation\Form\Element $e, $ruleSet)
 {
     if (!\strtotime($ruleSet)) {
         throw new \Foundation\Exception("The ruleset for DateBefore must be a valid PHP date string");
     }
     parent::__construct($e, $ruleSet);
 }

 /**
  * Construct
  * Check the ruleSet
  *
  * @param \Foundation\Form\Element $e
  * @param mixed $ruleSet
  */
 public function __construct(\Foundation\Form\Element $e, $ruleSet)
 {
     if (\is_null($ruleSet)) {
         throw new \Foundation\Exception("The ruleset for SpeicifcString must be set.");
     }
     parent::__construct($e, $ruleSet);
 }

 /**
  * Constructs a new validator, initializing the minimum valid value.
  *
  * @param \Zikula_ServiceManager $serviceManager The current service manager instance.
  * @param integer                $value          The minimum valid value for the field data.
  * @param string                 $errorMessage   The error message to return if the field data is not valid.
  *
  * @throws \InvalidArgumentException If the minimum value specified is not an integer.
  */
 public function __construct(\Zikula_ServiceManager $serviceManager, $value, $errorMessage = null)
 {
     parent::__construct($serviceManager, $errorMessage);
     if (!isset($value) || !is_int($value) || $value < 0) {
         throw new \InvalidArgumentException($this->__('An invalid integer value was received.'));
     }
     $this->value = $value;
 }

 /**
  * Do our own constructor so we can set the maxfilesize and check the ruleSet
  * @param \Foundation\Form\Element $e the element we are validating
  * @param integer $sizeInBytes
  */
 public function __construct(\Foundation\Form\Element $element, $sizeInBytes)
 {
     if (!($integer = \intval($sizeInBytes))) {
         throw new \Foundation\Exception("The ruleset for MaximumFileSize must be an integer. Value: '{$sizeInBytes}'");
     }
     parent::__construct($element, $integer);
     $this->e->setMaxSize($this->ruleSet);
 }

 /**
  * Constructs a new validator, initializing the maximum valid string length value.
  *
  * @param \Zikula_ServiceManager $serviceManager The current service manager instance.
  * @param integer                $length         The maximum valid length for the string value.
  * @param string                 $errorMessage   The error message to return if the string data exceeds the maximum length.
  *
  * @throws \InvalidArgumentException Thrown if the maximum string length value is not an integer or is less than zero.
  */
 public function __construct(\Zikula_ServiceManager $serviceManager, $length, $errorMessage = null)
 {
     parent::__construct($serviceManager, $errorMessage);
     if (!isset($length) || !is_int($length) || $length < 0) {
         throw new \InvalidArgumentException($this->__('An invalid string length was received.'));
     }
     $this->length = $length;
 }

 /**
  * @param string $allowedTags
  */
 public function __construct(...$allowedValues)
 {
     parent::__construct();
     if (!$allowedValues) {
         throw new \InvalidArgumentException('__construct() expects at least 1 parameter');
     }
     $this->allowedValues = $allowedValues;
 }

 /**
  * Constructs the validator, initializing the regular expression.
  *
  * @param \Zikula_ServiceManager $serviceManager    The current service manager instance.
  * @param string                 $regularExpression The PCRE regular expression against which to validate the data.
  * @param string                 $errorMessage      The error message to return if the data does not match the expression.
  *
  * @throws \InvalidArgumentException Thrown if the regular expression is not valid.
  */
 public function __construct(\Zikula_ServiceManager $serviceManager, $regularExpression, $errorMessage = null)
 {
     parent::__construct($serviceManager, $errorMessage);
     if (!isset($regularExpression) || !is_string($regularExpression) || empty($regularExpression)) {
         throw new \InvalidArgumentException($this->__('An invalid regular expression was received.'));
     }
     $this->regularExpression = $regularExpression;
 }

 public function __construct($pattern)
 {
     if (is_string($pattern)) {
         $this->setPattern($pattern);
         parent::__construct(array());
         return;
     }
     parent::__construct($pattern);
 }