PHP AbstractValidator::__construct方法代码示例

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

 /**
  * 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_null($ruleSet)) {
         throw new \Foundation\Exception("The ruleset for SpeicifcString must be set.");
     }
     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 (!\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_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);
 }

 /**
  * 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);
 }

 /**
  * @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;
 }

 /**
  * 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 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;
 }

 /**
  * 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;
 }

 /**
  * 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;
 }

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

 /**
  * Constructor for barcodes
  *
  * @param array|string $options Options to use
  */
 public function __construct($options = null)
 {
     if (!is_array($options) && !$options instanceof \Zend\Config\Config) {
         $options = array('adapter' => $options);
     }
     if (array_key_exists('options', $options)) {
         $options['options'] = array('options' => $options['options']);
     }
     parent::__construct($options);
 }

 /**
  * @param int|float|string $min
  * @param int|float|string $max
  */
 public function __construct($min, $max)
 {
     parent::__construct();
     $this->min = $min;
     $this->max = $max;
     if (is_string($min) && !is_numeric($min) && is_string($max) && !is_numeric($max)) {
         $this->isStringComparison = true;
     } else {
         $this->min = (double) $this->min;
         $this->max = (double) $this->max;
     }
 }