PHP IteratorIterator::__construct方法代碼示例

 /**
  * Ensures that the inner iterator is both Traversable and Countable
  *
  * {@inheritdoc}
  *
  * @throws InvalidArgumentException
  */
 public function __construct(\Traversable $iterator)
 {
     if (!$iterator instanceof \Countable) {
         throw new InvalidArgumentException('The inner iterator for an ItemIterator must be Countable.');
     }
     parent::__construct($iterator);
 }

 /**
  * constructor
  *
  * @param Diggin_Scraper_Evaluator_Abstract $callback
  */
 public function __construct(\Diggin\Scraper\Evaluator\AbstractEvaluator $callback)
 {
     if ($filters = $callback->getProcess()->getFilters()) {
         $callback = $this->_apply($callback, $filters);
     }
     return parent::__construct($callback);
 }

 public function __construct(FileInterface $file, FileSpec $spec, RecordSpecRecognizerInterface $recognizer, ValueFormatterInterface $formatter)
 {
     parent::__construct($file);
     $this->spec = $spec;
     $this->recognizer = $recognizer;
     $this->formatter = $formatter;
 }

 public function __construct($iterator = null)
 {
     if (is_array($iterator)) {
         $iterator = new ArrayIterator($iterator);
     }
     parent::__construct($iterator);
 }

 /**
  * @inheritDoc
  */
 public function __construct($path, $separator = ',')
 {
     $file = new SplFileObject($path);
     $file->setFlags(SplFileObject::READ_CSV | SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY);
     $file->setCsvControl($separator);
     parent::__construct($file);
 }

 /**
  *
  * @param array $data
  * @param \MUtil_Model_ModelAbstract $model
  * @param boolean $formatted
  * @return \Gems_FormattedData
  */
 public function __construct($data, \MUtil_Model_ModelAbstract $model, $formatted = true)
 {
     $this->data = parent::__construct(new \ArrayObject($data));
     $this->model = $model;
     $this->setFormatted($formatted);
     return $this;
 }

 public function __construct($iterator, $reducer)
 {
     if (!is_callable($reducer)) {
         throw new Exception('must pass valid reducer callback to this iterator');
     }
     $this->reducer = $reducer;
     parent::__construct($iterator);
 }

 public function __construct(Iterator $iterator, $selector)
 {
     parent::__construct($iterator);
     if ($selector === null) {
         throw new InvalidArgumentException("Selector must not be null.");
     }
     $this->selector = $selector;
 }

 /**
  * Constructor
  *
  * @param PMF_Category $parent Parent PMF_Category object
  * 
  * @return void
  */
 public function __construct(PMF_Category_Tree_DataProvider_Interface $dataProvider, PMF_Category $parent = NULL)
 {
     $parentId = $parent ? (int) $parent->getId() : 0;
     $resultset = $dataProvider->getData($parentId);
     parent::__construct($resultset);
     $this->parent = $parent;
     $this->dataProvider = $dataProvider;
 }

 public function __construct(IIterator $outerIterator, IIterator $innerIterator)
 {
     parent::__construct($outerIterator);
     self::__constructIterator();
     $this->outerIterator =& $this->iterator;
     $this->innerIterator = $innerIterator;
     $this->innerValuesIterator = new EmptyIterator();
 }

 public function __construct(Traversable $iterator, $classNameModel)
 {
     parent::__construct($iterator);
     $this->classNameModel = $classNameModel;
     if (!is_subclass_of($classNameModel, Internals\Model::className()) && !in_array(Internals\Model::className(), class_parents($classNameModel))) {
         throw new ObjectException("{$classNameModel} must be subclass of " . Internals\Model::className());
     }
 }

 public function __construct(\Traversable $iterator, $callback)
 {
     if (!is_callable($callback)) {
         throw new \InvalidArgumentException(sprintf('Callback should be callable, "%s" given.', gettype($callback)));
     }
     parent::__construct($iterator);
     $this->callback = $callback;
 }

 /**
  * @param \Traversable   $iterator Traversable iterator
  * @param array|\Closure $callback Callback used for iterating
  *
  * @throws InvalidArgumentException if the callback if not callable
  */
 public function __construct(\Traversable $iterator, $callback)
 {
     parent::__construct($iterator);
     if (!is_callable($callback)) {
         throw new InvalidArgumentException('The callback must be callable');
     }
     $this->callback = $callback;
 }

 public function __construct(\Traversable $iterator, $callback)
 {
     if (!is_callable($callback)) {
         throw new \InvalidArgumentException("Provided callback should be callable. Got " . gettype($callback));
     }
     parent::__construct($iterator);
     $this->callback = $callback;
 }

 function __construct(\Iterator $iterator, $flags = CachingIterator::CALL_TOSTRING)
 {
     $flags = $this->validateFlags($flags);
     if ($flags & self::FULL_CACHE) {
         $this->fullCacheIterator = new ArrayIterator();
     }
     $this->flags = $flags;
     parent::__construct($iterator);
 }