Yield all machines under this pool
424905
def _clones(self):
        """"""
        vbox = VirtualBox()
        machines = []
        for machine in vbox.machines:
            if machine.name == self.machine_name:
                continue
            if machine.name.startswith(self.machine_name):
                machines.append(machine)
        return machines
297531
def _iter_all_paths(start, end, rand=False, path=tuple()):
    """"""
    path = path + (start, )
    if start is end:
        yield path
    else:
        nodes = [start.lo, start.hi]
        if rand: # pragma: no cover
            random.shuffle(nodes)
        for node in nodes:
            if node is not None:
                yield from _iter_all_paths(node, end, rand, path)
877398
def _slice_generator(self, index):
        """"""
        start, stop, step = index.indices(len(self))
        for i in range(start, stop, step):
            yield self.get_blob(i)
1057330
def iter(self, start=0, count=1000):
        
        cursor = '0'
        _loads = self._loads
        stop = start + count
        while cursor:
            cursor = self._client.lrange(self.key_prefix, start, stop)
            for x in cursor or []:
                yield _loads(x)
            start += (count + 1)
            stop += (count + 1)
1339268
def suspend_all(self):
        
        pool = Pool(concurrency=3)
        for node in self.nodes.values():
            pool.append(node.suspend)
        yield from pool.join()
770755
def reset_all(self, suppress_logging=False):
        
        pool_names = list(self.pools)
        for name in pool_names:
            self.reset(name, suppress_logging)
621037
def codes(self):
        '''
        
        '''
        for start, end in self:
            for item in range(start, end):
                yield item
422092
def build_machine(lines):
    """"""
    if lines == []:
        raise SyntaxError('Empty file')
    else:
        machine = Machine(lines[0].split())
        for line in lines[1:]:
            if line.strip() != '':
                machine.add_state(line)
    machine.check()
    return machine
1327758
def each
      (1..ROWS).each do |r|
        (1..COLS).each do |c|
          yield(r, c, self[r, c])
        end
      end
    end
1267331
def _get_batches(self, items):
        """"""
        for i in xrange(0, len(items), self.max_batch_size):
            yield items[i:i + self.max_batch_size]
790075
def each
      @dir.synchronize do
        ensure_reader_open
        (0...@reader.max_doc).each do |i|
          yield @reader[i].load unless @reader.deleted?(i)
        end
      end
    end
722862
def each
      documents = load_docs
      documents.each { |doc| yield doc }
      while more?
        return kill if limited? && @limit <= 0
        documents = get_more
        documents.each { |doc| yield doc }
      end
    end
248203
def run_all():
    '''
    
    '''
    plugins = list_plugins()
    ret = {}
    for plugin in plugins:
        ret.update(run(plugin))
    return ret
1212025
def all_my_hosts_and_services(self):
        
        for what in (self.hosts, self.services):
            for item in what:
                yield item
920064
def Run(self):
    """"""
    count = 0
    for count, input_data in enumerate(self.GetInput()):
      if count % 2000 == 0:
        logging.debug("%d processed.", count)
      args = (input_data, self.out_queue, self.token)
      self.thread_pool.AddTask(
          target=self.IterFunction, args=args, name=self.THREAD_POOL_NAME)

    while count >= 0:
      try:
        # We only use the timeout to wait if we got to the end of the Queue but
        # didn't process everything yet.
        out = self.out_queue.get(timeout=self.QUEUE_TIMEOUT, block=True)
        if out:
          yield out
          count -= 1
      except queue.Empty:
        break

    # Join and stop to clean up the threadpool.
    self.thread_pool.Stop(join_timeout=THREADPOOL_JOIN_TIMEOUT)
920863
public function callAllPromises()
    {
        $pool = $this->pool;

        usort($pool, function ($a, $b) {
            return $a['priority'] - $b['priority'];
        });

        foreach ($pool as $node) {
            $promise = $node['promise'];
            $promise();
        }
    }
240783
def iterator(self):
        
        if not self._result_cache:
            len(self)
        for r in self._result_cache:
            yield r