Get the current build.

@return mixed
777550
public function getBuild()
    {
        if (
            $this->git->isVersionComingFromGit() &&
            ($value = $this->git->version('build'))
        ) {
            return $value;
        }

        if ($this->config->get('build.mode') === Constants::BUILD_MODE_NUMBER) {
            return $this->config->get('build.number');
        }

        return $this->git->getCommit();
    }
1104587
public function getCurrentResource()
    {
        if (!$this->currentResource) {
            $request = $this->container->make('request');
            $this->currentResource = $this->detector->resourceByRequest($request);
        }

        return $this->currentResource;
    }
503167
public function current()
    {
        if (false !== $this->value) {
            return $this->value;
        }

        $this->value = $this->getCurrentRecord();

        return $this->value;
    }
353288
public function current()
    {
        $icon = current($this->icon);

        $fa = clone $this;

        return $fa->addClass($icon);
    }
110945
public function current() {
		if ($this->string === null) {
			$this->string = fgets($this->file);
		}
		
		$string = rtrim($this->string, "\n\r");
		
		if ($this->delimiter === null) {
			return $string;
		} 
		
		$dataRaw = explode($this->delimiter, $string);
		$data    = [];

		if ($this->partsNames === null) {
			foreach ($dataRaw as $key => $part) {
				$data[self::UNNAMED_PREFIX . $key] = $part;
			}
			
			return $data;
		}
		
		foreach ($dataRaw as $key => $part) {
			if (isset($this->partsNames[$key])) {
				$data[$this->partsNames[$key]] = $part;
				continue;
			}
			
			$data[self::UNNAMED_PREFIX . $key] = $part;
		}

		return $data;
	}
697936
public function current()
    {
    	$data = $this->dbi->current();
		$class_name = $this->__class_name;
		$object = new $class_name($data['id']);
//		$object->set_id($data['id']);
		$object->data = $data;
		$object->set_is_loaded(true);
		return $object;
    }
86035
public function getUpdated()
    {
        return $this->getCachedProperty(
            'updated',
            function () {
                $element = $this->query('atom:updated', Node::SINGLE | Node::REQUIRED);

                /** @var Element $this */
                return $this->getExtensions()->parseElement($this, $element);
            }
        );
    }
902115
public function current()
    {
        if (!isset($this->rs)) {
            $this->doRs();
        }

        return $this->rs[$this->currentKey];
    }
396501
public function current()
	{
		$scopeFact = VariableBinding::current();
		if ( ! $scopeFact || ! is_array( $scopeFact ) )
		{
			$this->scopeFactGUID = null;
			return null;
		}

		$fact = $scopeFact['result'];

		/**
		 * @var FactVariableBinding $binding
		 */
		$binding = $scopeFact['lastFactBinding'];

		$this->aspectsCovered = $binding->aspectsCovered;
		$this->aspectsDefined = $binding->aspectsDefined;
		$this->uncoveredAspectFacts = $scopeFact['uncoveredAspectFacts'];

		$this->scopeFactGUID = isset( $scopeFact['GUID'] )
			? $scopeFact['GUID']
			: null;

		return $fact;
	}
1119824
public function getNextBuildTime()
    {
        $nextBuildTime = null;
        $build = null;
        while ($this->builds->valid()) {
            $build = $this->builds->current();
            if ($build->getNextBuildTime() <= $nextBuildTime
               || $nextBuildTime === null) {
                if ($build->getStatus() != BuildInterface::STOPPED) {
                    $buildTime = $build->getNextBuildTime();

                    if ($buildTime !== null && !$build->isQueued()) {
                        $nextBuildTime = $buildTime;
                        /*
                         * Need to write to queue here and have a FIFO
                         * check before if not already in queue
                         */
                        //if (!in_array($build, $this->_queue)) {
                            $this->queue[] = $build;
                        $build->enqueue();
                        //}
                    } else {
                        /*
                         * we need to check if a scheduled build has a lower build time
                         * but we dont want to queue it again
                         */
                        $nextBuildTime = $buildTime;
                    }
                }
            }
            $this->builds->next();
        }
        usort($this->queue, array($this, 'sortQueue'));
        $this->builds->rewind();

        return $nextBuildTime;
    }
1206024
public function getCurrentDatabase()
    {
        if ($this->currentDatabase === null) {
            $compiler = $this->connection->schemaCompiler();
            $result = $compiler->currentDatabase($this->connection->getDSN());

            if (is_array($result)) {
                $this->currentDatabase = $this->connection->column($result['sql'], $result['params']);
            } else {
                $this->currentDatabase = $result;
            }
        }

        return $this->currentDatabase;
    }
278682
protected function getBuildFile()
    {
        $buildfile = getcwd().'/build.yml';

        if (true === $this->input->hasParameterOption('--buildfile')) {
            $buildfile = realpath($this->input->getParameterOption('--buildfile'));
        }

        if (is_file($buildfile) && is_readable($buildfile)) {
            return $buildfile;
        }

        throw new \Exception(
            sprintf('Could not find build file "%s"', $buildfile)
        );
    }
669225
protected function buildConfig()
    {
        if ($this->buildCache === null) {
            // Read the top config first:
            $built = [];
            $built = array_replace_recursive($built, $this->values['_top']);

            if (array_key_exists($this->environment, $this->values)) {
                $built = array_replace_recursive($built, $this->values[$this->environment]);
            }

            $this->buildCache = $built;
        }

        return $this->buildCache;
    }
141665
public function build()
	{
		switch ($this->type) {
			case 'asset':
				return $this->getBuildAsset();
				break;

			case 'page':
				return $this->getBuildPage();
				break;

			case 'post':
				return $this->getBuildPost();
				break;

			case 'category':
				return $this->getBuildCategory();
				break;

			case 'pagination':
				return $this->getBuildPagination();
				break;

			case 'author':
				return $this->getBuildAuthor();
				break;

			case 'site':
				return new BuildSite($this->config, $this->getBuildAsset(), $this->getBuildPage(), $this->getBuildPost(), $this->getBuildCategory(), $this->getBuildPagination(), $this->getBuildAuthor() );
				break;
			
			default:
				return;
				break;
		}
	}
992597
public function current()
    {
        $callback = $this->_callback;

        return $callback(parent::current(), $this->key(), $this->_innerIterator);
    }
394891
public function get_current_instance() {
        if ($this->get_status() == self::INSTANCE_STATUS_ACTIVE || $this->get_status() == self::INSTANCE_STATUS_NEEDUPDATE) {
            return $this;
        }
        return $this->get_controller()->get_current_instance($this->data->raterid, $this->data->itemid);
    }
350647
protected function buildStored()
    {
        return $this->files->exists($file_path = $this->config['build_metadata_path'])
            ? $this->files->get($file_path, $this->use_locking)
            : null;
    }