Esempio n. 1
0
 /**
  * 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;
     }
 }
Esempio n. 3
0
 public function __construct($sFolderPath, $sLanguage = null, $sCountry = null, $sLibName = null)
 {
     $this->sLanguage = $sLanguage;
     $this->sCountry = $sCountry;
     $this->sLibName = $sLibName;
     parent::__construct(new \DirectoryIterator($sFolderPath));
 }
Esempio n. 4
0
 /**
  * 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);
 }
Esempio n. 6
0
 /**
  * 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;
 }
Esempio n. 11
0
 /**
  * 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;
     }
 }
Esempio n. 12
0
 /**
  * @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);
 }
Esempio n. 13
0
 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);
 }
Esempio n. 16
0
 /**
  * {@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);
    }
Esempio n. 18
0
 /**
  *
  * Ctor
  * @param array|\Iterator $iterator
  */
 public function __construct($iterator)
 {
     if (!$iterator instanceof \Iterator) {
         $iterator = new \ArrayIterator($iterator);
     }
     parent::__construct($iterator);
 }
Esempio n. 19
0
 /**
  * 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);
 }
Esempio n. 21
0
 /**
  * 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', '\\');
         }
     }
 }
Esempio n. 22
0
 public function __construct($path, $predicate)
 {
     $this->predicate = $predicate;
     $this->path = $path;
     $it = new RecursiveDirectoryIterator($path);
     $flatIterator = new RecursiveDirectoryIterator($it);
     parent::__construct($flatIterator);
 }
Esempio n. 23
0
 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);
 }
Esempio n. 25
0
 public function __construct(\Iterator $iterator, $callback)
 {
     parent::__construct($iterator);
     if (!is_callable($callback)) {
         throw new InvalidArgumentException('The callback must be callable');
     }
     $this->callback = $callback;
 }
Esempio n. 26
0
 /**
  * @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;
 }
Esempio n. 27
0
 /**
  * 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;
 }
Esempio n. 30
0
 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;
 }