Get the next release to come.

@return string
175017
public function getNextRelease()
    {
        if (!$this->nextRelease) {
            $manual = $this->getOption('release');
            $manual = $this->isRelease($manual) ? $manual : null;

            $this->nextRelease = $manual ?: $this->bash->getTimestamp();
        }

        return $this->nextRelease;
    }
499505
public function release()
    {
        $path = sprintf('/%s/%s/%s/%s', MoipResource::VERSION, self::PATH, $this->getId(), 'release');

        $response = $this->httpRequest($path, Requests::POST, []);

        return $this->populate($response);
    }
1089690
public function getNextTailVersion()
    {
        if (count($this->stabilityVersion) && $this->stabilityVersion[0] != 'stable') {
            return implode('.', $this->version);
        }
        $v = $this->version;
        $last = count($v) - 1;
        if ($v[$last] !== '*') {
            ++$v[$last];
        }

        return implode('.', $v);
    }
950568
public function getNext()
    {
        return $this
            ->where(self::ATTR_PAGE, $this->getPageId())
            ->where(self::ATTR_CREATED_AT, '>', $this->getEditedTime()->getTimestamp())
            ->orderBy(self::ATTR_CREATED_AT, 'asc')
            ->first();
    }
171901
public function getNextRunDate()
    {
        if ($this->nextRunDate === null) {
            $nextRun = $this->cronExpression->getNextRunDate();
            $this->nextRunDate = $nextRun->getTimestamp();
        }

        return $this->nextRunDate;
    }
608331
public function getNextLine()
    {
        if ( $this->hasMoreMailData === false )
        {
            $this->nextMail();
        }
        // finished?
        if ( $this->fp == null || feof( $this->fp ) )
        {
            if ( $this->fp != null )
            {
                fclose( $this->fp );
                $this->fp = null;
            }
            return null;
        }

        // get one line
        $next = fgets( $this->fp );
        if ( $next == "" && feof( $this->fp ) )
        {
            return null;
        }
        return $next;
    }
47468
public function getNextVersion($from)
    {
        $found = false;
        foreach (array_keys($this->versions) as $timestamp) {
            if ($from === null) {
                return $timestamp;
            }

            if ($timestamp == $from) {
                $found = true;
                continue;
            }

            if ($found) {
                return $timestamp;
            }
        }

        return;
    }
704596
protected function getCurrentVersion()
    {
        $version = $this->getBinary()->run('--version');
        $version = str_replace('v', null, $version);

        return $version;
    }
608960
public function next() {
		if ($this->currentRecord < count($this->files)) {
			$file = $this->files[$this->currentRecord];
			$this->currentRecord++;
			return $file;
		} else {
			return false;
		}
	}
1110438
public function getNext()
    {
        $idList = $this->getIds();
        if (false === ($taskId = current($idList))) {
            return null;
        }

        return $this->getTask($taskId);
    }
835149
public function getLastUpdated()
    {
        $packages = Package::get()->limit(1);
        if (!$packages->count()) {
            return '';
        }
        /** @var DBDatetime $datetime */
        $datetime = $packages->first()->dbObject('LastEdited');
        return $datetime->Date() . ' ' . $datetime->Time12();
    }
772940
public function get_next_stage() {
        if ($this->oneclickbackup) {
            // Its a one click backup.
            // The default filename is backup.mbz, this normally gets set to something useful in the confirmation stage.
            // because we skipped that stage we must manually set this to a useful value.
            $tasks = $this->ui->get_tasks();
            foreach ($tasks as $task) {
                if ($task instanceof backup_root_task) {
                    // Find the filename setting.
                    $setting = $task->get_setting('filename');
                    if ($setting) {
                        // Use the helper objects to get a useful name.
                        $filename = backup_plan_dbops::get_default_backup_filename(
                            $this->ui->get_format(),
                            $this->ui->get_type(),
                            $this->ui->get_controller_id(),
                            $this->ui->get_setting_value('users'),
                            $this->ui->get_setting_value('anonymize')
                        );
                        $setting->set_value($filename);
                    }
                }
            }
            return backup_ui::STAGE_FINAL;
        }
        return parent::get_next_stage();
    }
561212
public function next() {
        $this->getCurrentIterator()->next();
        if (!$this->getCurrentIterator()->valid()) {
            $this->moveToNextValidIterator();
        }
        return $this->current();
    }
1308270
public function getNextCallable()
    {
        if(!$this->initiated)
        {
            reset($this->callables);

            $this->initiated = true;

            return current($this->callables);
        }

        return next($this->callables);
    }
473818
private static function getNextItem()
    {
        $pendingStatusValue = ezpContentPublishingProcess::STATUS_PENDING;
        $workingStatusValue = ezpContentPublishingProcess::STATUS_WORKING;

        $sql = <<< SQL
SELECT *
FROM
  ezpublishingqueueprocesses p,
  ezcontentobject_version v
WHERE p.status = $pendingStatusValue
  AND p.ezcontentobject_version_id = v.id
  AND v.contentobject_id NOT IN (
    SELECT v.contentobject_id
    FROM ezpublishingqueueprocesses p,
      ezcontentobject_version v
    WHERE
      p.ezcontentobject_version_id = v.id
      AND p.status = $workingStatusValue
  )
ORDER BY p.created, p.ezcontentobject_version_id ASC
SQL;
        $db = eZDB::instance();
        $rows = $db->arrayQuery( $sql, array( 'offset' => 0, 'limit' => 1 ) );
        if ( count( $rows ) == 0 )
            return false;

        /** @var ezpContentPublishingProcess[] $persistentObjects */
        $persistentObjects = eZPersistentObject::handleRows( $rows, 'ezpContentPublishingProcess', true );
        return $persistentObjects[0];
    }
547689
public function getVersionsToSync()
    {
        $versionsToSync      = [ ];
        $remote              = $this->client($this->setting('connection'));
        $currentVersions     = $this->project->getRefs();
        $allowedVersionRange = new expression($this->setting('sync.constraints.versions'));
        $tags                = $remote->getTags($this->setting('repository'), $this->setting('owner'));
        $skipPatch           = $this->setting('sync.constraints.skip_patch_versions', false);
        $skipMinor           = $this->setting('sync.constraints.skip_minor_versions', false);
        $skipPatch           = $skipMinor === true ? true : $skipPatch; // if we skip minors, we automaticly skip patches as well

        $this->fire('versions.start', [ $tags ]);

        foreach ( $tags as $tag => $sha )
        {
            try
            {
                $version = new version($tag);
            }
            catch (SemVerException $e)
            {
                continue;
            }

            // Check all version constraints
            if ( $version->satisfies($allowedVersionRange) === false || in_array($version->getVersion(), $currentVersions, true) )
            {
                continue;
            }
            if ( $skipPatch === true && $version->getPatch() !== 0 )
            {
                continue;
            }
            if ( $skipMinor === true && $version->getMinor() !== 0 )
            {
                continue;
            }

            // This version is inside constraints, add it
            $versionsToSync[] = $version;
        }

        $this->fire('versions.finish', [ $versionsToSync ]);
        return $versionsToSync;
    }
510324
private function getNextInteration()
    {
        // Get the next interator.
        $migrations = new Filesystem(new Adapter(base_path('database/migrations')));

        try {
            $files = $migrations->listContents();
        } catch (\Exception $exception) {
            $this->error($exception->getMessage());

            exit(1);
        }

        $files_filtered = array_filter($files, function ($value) {
            return stripos($value['filename'], date('Y_m_d')) !== false;
        });

        if (count($files_filtered) == 0) {
            return 1;
        }

        $files_filtered = array_column($files_filtered, 'path');

        sort($files_filtered);
        $latest_file = array_pop($files_filtered);
        $latest_details = explode('_', $latest_file);

        return (int) $latest_details[3] + 1;
    }