/** * Takes both a directory iterator and a file extension and only returns * results matching the particular extension. * * @access public */ public function __construct(DirectoryIterator $it, $ext, $whitelisted = false) { parent::__construct($it); $this->_it = $it; $this->_ext = $ext; $this->_whitelisted = $whitelisted; }
/** * __construct * * Creates a new DirectoryIterator that can be used in a foreach loop * (providing an SplFileInfo object in each loop pass.) * * @access public * @throws Exception If the provided path is not a directory or not readable. * @param string $path A filesystem path to a directory on which to operate. * @param array $allowedExtensions Optional indexed array of allowed file extensions, without the leading '.'s. */ public function __construct($path, $allowedExtensions = null) { parent::__construct(new DirectoryIterator($path)); if (!is_null($allowedExtensions)) { $this->allowed = $allowedExtensions; } }
public function __construct($sFolderPath, $sLanguage = null, $sCountry = null, $sLibName = null) { $this->sLanguage = $sLanguage; $this->sCountry = $sCountry; $this->sLibName = $sLibName; parent::__construct(new \DirectoryIterator($sFolderPath)); }
/** * Prepares filter with the iterator and the maximum age of session * files we want to compare to. * * @param \Iterator $iterator The iterator with the files we want to compare to * @param integer $maximumAge The maximum age of the session files we want to load */ public function __construct(\Iterator $iterator, $maximumAge) { // call parent constructor parent::__construct($iterator); // initialize the maximum age of the session files we want to load $this->maximumAge = $maximumAge; }
function __construct(\Iterator $iterator, array $filters) { foreach ($filters as $filter) { $this->filters[] = $filter; } parent::__construct($iterator); }
/** * Initializes an instance of <b>OfTypeIterator</b>. * * @param Iterator $iterator * @param string $type */ public function __construct(Iterator $iterator, $type) { parent::__construct($iterator); switch (strtolower($type)) { case 'int': case 'integer': $this->acceptCallback = function ($current) { return is_int($current); }; break; case 'float': case 'double': $this->acceptCallback = function ($current) { return is_float($current); }; break; case 'string': $this->acceptCallback = function ($current) { return is_string($current); }; break; case 'bool': case 'boolean': $this->acceptCallback = function ($current) { return is_bool($current); }; break; default: $this->acceptCallback = function ($current) use($type) { return $current instanceof $type; }; } }
/** * @param \Traversable $transitions * @param object $subject * @param \ArrayAccess $context * @param EventInterface $event */ public function __construct(\Traversable $transitions, $subject, \ArrayAccess $context, EventInterface $event = null) { parent::__construct(new \IteratorIterator($transitions)); $this->subject = $subject; $this->context = $context; $this->event = $event; }
/** Construct a Sns_Callback_Filter_Iterator * * @param it inner iterator (iterator to filter) * @param callback callback function * @param mode any of USE_VALUE, USE_KEY, USE_BOTH * @param flags any of 0, REPLACE */ public function __construct(Iterator $it, $callback, $mode = self::USE_VALUE, $flags = 0) { parent::__construct($it); $this->callback = $callback; $this->mode = $mode; $this->flags = $flags; }
function __construct(\Iterator $iterator, array $ignored) { parent::__construct($iterator); foreach ($ignored as $folder) { $this->ignored[] = $folder; } }
/** * RegexDirectoryIterator constructor. * * @param string $path * The path to scan. * @param string $regex * The regular expression to match, including delimiters. For example, * /\.yml$/ would list only files ending in .yml. */ public function __construct($path, $regex) { // Use FilesystemIterator to not iterate over the the . and .. directories. $iterator = new \FilesystemIterator($path); parent::__construct($iterator); $this->regex = $regex; }
/** * Creates a FilterIterator for Zym_Navigation_Iterator_Dfs * * @param Zym_Navigation_Iterator_Dfs $iterator iterator to iterate * @param bool $parentDependent [optional] whether page should be * invisible if parent is invisible, * defaults to true */ public function __construct(Zym_Navigation_Iterator_Dfs $iterator, $parentDependent = null) { parent::__construct($iterator); if (is_bool($parentDependent)) { $this->_parentDependent = $parentDependent; } }
/** * @param \Iterator $sourceIterator Iterator to wrap and filter * @param \Iterator $targetIterator Iterator used to compare against the source iterator * @param FilenameConverterInterface $sourceConverter Key converter to convert source to target keys * @param FilenameConverterInterface $targetConverter Key converter to convert target to source keys */ public function __construct(\Iterator $sourceIterator, \Iterator $targetIterator, FilenameConverterInterface $sourceConverter, FilenameConverterInterface $targetConverter) { $this->targetIterator = $targetIterator; $this->sourceConverter = $sourceConverter; $this->targetConverter = $targetConverter; parent::__construct($sourceIterator); }
function __construct(array $ignore, $path, $it, $role) { $this->ignore = $ignore; $this->path = $path; $this->role = $role; parent::__construct($it); }
/** * Constructor. * * @param \Iterator $iterator The Iterator to filter * @param array $directories An array of directories to exclude */ public function __construct(\Iterator $iterator, array $directories) { foreach ($directories as $directory) { $this->patterns[] = '#(^|/)' . preg_quote($directory, '#') . '(/|$)#'; } parent::__construct($iterator); }
/** * Constructor. * * @param \RecursiveIteratorIterator $iterator The Iterator to filter * @param array $comparators An array of \NumberComparator instances */ public function __construct(\RecursiveIteratorIterator $iterator, array $comparators) { $minDepth = 0; $maxDepth = INF; foreach ($comparators as $comparator) { switch ($comparator->getOperator()) { case '>': $minDepth = $comparator->getTarget() + 1; break; case '>=': $minDepth = $comparator->getTarget(); break; case '<': $maxDepth = $comparator->getTarget() - 1; break; case '<=': $maxDepth = $comparator->getTarget(); break; default: $minDepth = $maxDepth = $comparator->getTarget(); } } $this->minDepth = $minDepth; $iterator->setMaxDepth(INF === $maxDepth ? -1 : $maxDepth); parent::__construct($iterator); }
/** * {@inheritdoc} */ public function __construct(\Iterator $iterator, array $options = []) { parent::__construct($iterator, $options); if (isset($options['active']) && $options['active']) { $this->active = $this['request']->attributes->get('_menu', []); } }
/** * Constructor. * * @param \RecursiveIteratorIterator $iterator The Iterator to filter * @param int $minDepth The min depth * @param int $maxDepth The max depth */ public function __construct(\RecursiveIteratorIterator $iterator, $minDepth = 0, $maxDepth = INF) { $this->minDepth = $minDepth; $iterator->setMaxDepth(INF === $maxDepth ? -1 : $maxDepth); parent::__construct($iterator); }
/** * * Ctor * @param array|\Iterator $iterator */ public function __construct($iterator) { if (!$iterator instanceof \Iterator) { $iterator = new \ArrayIterator($iterator); } parent::__construct($iterator); }
/** * Constructor */ public function __construct($note, $limit) { $this->note = new ArrayObject($note); $this->limit = $this->getBlockLimit($limit); $this->count = 0; parent::__construct($this->note->getIterator()); }
/** * Constructor * * @param string $filePath * @param array $options */ public function __construct($filePath, array $options = array()) { $options['skip_empty'] = true; $this->innerIterator = new XlsxFileIterator($filePath, $options); $this->options = $options; parent::__construct($this->innerIterator); }
/** * Create an instance of the locator iterator * * Expects either a directory, or a DirectoryIterator (or its recursive variant) * instance. * * @param string|DirectoryIterator $dirOrIterator */ public function __construct($dirOrIterator = '.') { if (is_string($dirOrIterator)) { if (!is_dir($dirOrIterator)) { throw new InvalidArgumentException('Expected a valid directory name'); } $dirOrIterator = new RecursiveDirectoryIterator($dirOrIterator); } if (!$dirOrIterator instanceof DirectoryIterator) { throw new InvalidArgumentException('Expected a DirectoryIterator'); } if ($dirOrIterator instanceof RecursiveIterator) { $iterator = new RecursiveIteratorIterator($dirOrIterator); } else { $iterator = $dirOrIterator; } parent::__construct($iterator); $this->setInfoClass('Zend_File_PhpClassFile'); // Forward-compat with PHP 5.3 if (version_compare(PHP_VERSION, '5.3.0', '<')) { if (!defined('T_NAMESPACE')) { define('T_NAMESPACE', 'namespace'); } if (!defined('T_NS_SEPARATOR')) { define('T_NS_SEPARATOR', '\\'); } } }
public function __construct($path, $predicate) { $this->predicate = $predicate; $this->path = $path; $it = new RecursiveDirectoryIterator($path); $flatIterator = new RecursiveDirectoryIterator($it); parent::__construct($flatIterator); }
function __construct(array $arr, \Pyrus\PackageInterface $parent, $phase, $lastversion = null) { $this->_parent = $parent; $this->_tasksNs = $this->_parent->getTasksNs(); $this->_installphase = $phase; $this->lastversion = $lastversion; parent::__construct($this->_inner = new \ArrayIterator($arr)); }
/** * Creates a filtered iterator using the callback to determine * which items are accepted or rejected. * * @param \Iterator $iterator The iterator to be filtered. * @param callable $callback The callback, which should return TRUE to accept the current item * or FALSE otherwise. May be any valid callable value. * The callback should accept up to three arguments: the current item, * the current key and the iterator, respectively. * ``` php * function my_callback($current, $key, $iterator) * ``` * * @throws InvalidArgumentException * * @since 1.2.0 */ public function __construct(\Iterator $iterator, $callback) { if (!is_callable($callback)) { throw new \InvalidArgumentException("Argument 2 of CallbackFilterIterator should be callable."); } $this->callback = $callback; parent::__construct($iterator); }
public function __construct(\Iterator $iterator, $callback) { parent::__construct($iterator); if (!is_callable($callback)) { throw new InvalidArgumentException('The callback must be callable'); } $this->callback = $callback; }
/** * @param ResponseCollection $iterator * @param CommandInterface $cmd */ public function __construct(\Iterator $iterator, CommandInterface $cmd) { if (!$iterator instanceof ResponseCollection) { throw new InvalidArgumentException('$iterator must be instance of EventManager\\Response\\ResponseCollection'); } parent::__construct($iterator); $this->command = $cmd; }
/** * Constructor * * @param \Iterator $iterator Inner Iterator * @param int $appearsAfter The unix timestamp of file modification time * after which the update should appear in the result list */ public function __construct(\Iterator $iterator, $appearsAfter) { parent::__construct($iterator); $this->appearsAfter = $appearsAfter; if (empty($this->appearsAfter) || !is_numeric($appearsAfter)) { throw new \InvalidArgumentException(sprintf('Second parameter is expected to be valid number, "%s" given for class "%s".', $appearsAfter, get_class($this))); } }
/** * Class init. * * @param \Iterator $iterator * @param callable $callback * * @throws InvalidArgumentException */ public function __construct(\Iterator $iterator, $callback) { if (!is_callable($callback)) { throw new \InvalidArgumentException("Invalid callback"); } $this->callback = $callback; parent::__construct($iterator); }
/** * @param Iterator * @param callable Signature: (mixed $current): bool. */ public function __construct(Iterator $iterator, $callback) { parent::__construct($iterator); if (!is_callable($callback)) { throw new Exception(pht('Callback must be callable.')); } $this->callback = $callback; }
public function __construct($path, Logger $logger = null, array $accepted_extensions = array(), array $ignored_directories = array()) { parent::__construct(new \DirectoryIterator($path)); $this->logger = $logger; //$this->setProcessFilesFlag($path); $this->accepted_extensions = $accepted_extensions; $this->ignored_directories = $ignored_directories; }