Get next filter.

@param int $step

@return AbstractFilter[]|mixed
434928
public function next($step = 1)
    {
        return $this->siblings(
            array_search($this, $this->parent->filters(), true) + $step
        );
    }
1167757
public function getServersForStep(DeployStep $step)
    {
        $servers = $step->getServers();
        foreach ($servers as $server) {
            $server->setLogger($this->logger);
            $server->setCommands($step->getCommands());
        }

        return $servers;
    }
391621
protected function delete($step)
    {
        $locationCollection = $this->matchLocations('delete', $step);

        $this->setReferences($locationCollection, $step);

        $locationService = $this->repository->getLocationService();

        foreach ($locationCollection as $location) {
            $locationService->deleteLocation($location);
        }

        return $locationCollection;
    }
527989
public function getRangeOptions($min, $max, $step)
    {
        $options = [];
        
        foreach (range($min, $max, $step) as $value) {
            $options[number_format($value, 1)] = number_format($value, 1);
        }
        
        return $options;
    }
138378
private function getArguments(StepNode $step)
    {
        if (! $step->hasArguments()) {
            return;
        }

        return implode(
            array_map(
                function (ArgumentInterface $argument) {
                    if (in_array($argument->getNodeType(), ['Table', 'ExampleTable'])) {
                        return implode(
                            array_map(
                                function ($arguments) {
                                    return $this->indent(self::INDENTATION * 2 + 4) . trim($arguments) . "\n";
                                },
                                explode("\n", $argument->getTableAsString())
                            )
                        );
                    }

                    if ('PyString' === $argument->getNodeType()) {
                        return $this->encapsulateAsPyString(
                            implode(
                                array_map(
                                    function ($arguments) {
                                        return rtrim($this->indent(self::INDENTATION * 2 + 2) . trim($arguments)) . "\n";
                                    },
                                    $argument->getStrings()
                                )
                            )
                        );
                    }
                },
                $step->getArguments()
            )
        );
    }
1061253
protected function steplogic($step) {
		if ( ! isset($this->_method_cache[$step])) {
			$dbh = $this->dbh();
			$class = \hlin\PHP::pnn(call_user_func($this->stepclass, $step));
			$this->_method_cache[$step] = $class::instance($dbh);
		}
		return $this->_method_cache[$step];
	}
1163011
function nextStep( $step )
    {
        foreach ( $this->StepTable as $key => $tableStep )
        {
            if ( $step['class'] == $tableStep['class'] )
            {
                return $this->StepTable[++$key];
            }
        }
        $retValue = null;
        return $retValue;
    }
761570
public function getNext(int $step = 1) : Token {
      $position = ($this->position + $step);
      return $this->items[$position] ?? new Token();
    }
644825
public function getNext($step = 1) {
      $position = ($this->position + $step);
      return isset($this->items[$position]) ? $this->items[$position] : null;
    }
636388
public function getFilters()
    {
        if (is_array($this->filters)) {
            return $this->filters;
        }

        $request = $this->getRequest();
        $toolbarFilters = $request->getPost('toolbarFilters', $request->getQuery('toolbarFilters'));
        $filters = [];
        if (($request->isPost() === true || $request->isGet() === true) &&
            null !== $toolbarFilters
        ) {
            foreach ($toolbarFilters as $uniqueId => $value) {
                if ($value != '') {
                    foreach ($this->getColumns() as $column) {
                        /* @var $column \ZfcDatagrid\Column\AbstractColumn */
                        if ($column->getUniqueId() == $uniqueId) {
                            $filter = new \ZfcDatagrid\Filter();
                            $filter->setFromColumn($column, $value);

                            $filters[] = $filter;

                            $column->setFilterActive($filter->getDisplayColumnValue());
                        }
                    }
                }
            }
        }

        if (! empty($filters)) {
            $this->filters = $filters;
        } else {
            // No user sorting -> get default sorting
            $this->filters = $this->getFiltersDefault();
        }

        return $this->filters;
    }
1100980
public function steps($steps)
    {
        if ( ! is_array($steps)) {
            $steps = [ $steps ];
        }

        $this->steps = $steps;

        return $this;
    }
1009146
protected function trash($step)
    {
        $locationCollection = $this->matchLocations('delete', $step);

        $this->setReferences($locationCollection, $step);

        $trashService = $this->repository->getTrashService();

        foreach ($locationCollection as $location) {
            $trashService->trash($location);
        }

        return $locationCollection;
    }
492027
function(step, next) {
      if (step.options.data != null) {
        step.data = step.options.data;
      } else {
        step.data = {};
      }
      return next();
    }
1183390
protected function trySteps(array $steps)
    {
        foreach ($steps as $step) {
            // Run each step and return if there's a result
            if ($result = $this->$step()) {
                return $result;
            }
        }

        return null;
    }
539785
public function getFilters()
    {
        if (null === $this->sorted) {
            if (!count($this->filters)) {
                $this->sorted = array();
            } else {
                ksort($this->filters);
                $this->sorted = call_user_func_array('array_merge', $this->filters);
            }
        }
        return $this->sorted;
    }
648905
def get_next_step(self):
        
        if self.layer_purpose != layer_purpose_aggregation:
            subcategory = self.parent.step_kw_subcategory.\
                selected_subcategory()
        else:
            subcategory = {'key': None}

        if is_raster_layer(self.parent.layer):
            return self.parent.step_kw_source

        # Check if it can go to inasafe field step
        inasafe_fields = get_non_compulsory_fields(
            self.layer_purpose['key'], subcategory['key'])

        if not skip_inasafe_field(self.parent.layer, inasafe_fields):
            return self.parent.step_kw_inasafe_fields

        # Check if it can go to inasafe default field step
        default_inasafe_fields = get_fields(
            self.layer_purpose['key'],
            subcategory['key'],
            replace_null=True,
            in_group=False
        )
        if default_inasafe_fields:
            return self.parent.step_kw_default_inasafe_fields

        # Any other case
        return self.parent.step_kw_source
676260
public function step($step = null)
    {
        if (isset($step)) {
            $this->step = $step;
            return $this;
        } else {
            return $this->step;
        }
    }