Should be called after answering the request to allow the Target
to check if all required registry values have been set correctly.

@return boolean False if required are missing.
340184
public function checkRegistryRequestsAnswers()
    {
        if ($this->_respTrackData && $this->currentUser instanceof \Gems_User_User) {
            $this->_respTrackData = $this->currentUser->applyGroupMask($this->_respTrackData);
        } else {
            if ($this->db instanceof \Zend_Db_Adapter_Abstract) {
                $this->refresh();
            }
        }

        return (boolean) $this->_respTrackData;
    }
1030834
protected function validateDbPortInstall()
    {
        $field = 'database.port';

        if ($this->isExcluded($field)) {
            return null;
        }

        $value = $this->getSubmitted($field);
        $label = $this->translation->text('Database port');

        if (empty($value)) {
            $this->setErrorRequired($field, $label);
            return false;
        }

        if (!is_numeric($value)) {
            $this->setErrorNumeric($field, $label);
            return false;
        }

        return true;
    }
370852
public function isAquired() {
        if (isset(self::$hFiles[$this->filename]))
            return is_resource(self::$hFiles[$this->filename]);
        return false;
    }
238921
public function afterRegistry()
    {
        parent::afterRegistry();

        $this->browse  = true;
        $this->caption = $this->_('Rounds with this condition');
        $this->onEmpty = $this->_('No rounds using this condition found');
    }
305290
public function verifyRequirements()
    {
        $this->findRequiredFiles($this->requirements->getRequiredFiles());
        $this->findRequiredTokens(new FunctionFinder(), $this->requirements->getRequiredFunctions());
        $this->findRequiredTokens(new ClassFinder(), $this->requirements->getRequiredClasses());
        $this->findRequiredTokens(new LangFinder(), [$this->requirements->getRequiredStrings()]);
        $this->findRequiredTokens(new CapabilityFinder(), [$this->requirements->getRequiredCapabilities()]);
        $this->findRequiredTokens(new TableFinder(), [$this->requirements->getRequiredTables()]);
        $this->findRequiredTokens(new TablePrefixFinder(), [$this->requirements->getRequiredTablePrefix()]);
        $this->findRequiredTokens(new BehatTagFinder(), $this->requirements->getRequiredBehatTags());
    }
140527
public function checkRegistryRequestsAnswers()
    {
        return $this->db instanceof \Zend_Db_Adapter_Abstract &&
                $this->logger instanceof \Gems_Log &&
                $this->project instanceof \Gems_Project_ProjectSettings &&
                $this->tracker instanceof \Gems_Tracker_TrackerInterface &&
                $this->translate instanceof \Zend_Translate;
    }
399915
public function afterRegistry()
    {
        parent::afterRegistry();

        if (! $this->menuActionController) {
            $this->menuActionController = $this->request->getControllerName();
        }
    }
343387
public function has_required_properties() {

        return (
            ! empty( $this->plural_name )
            && ! empty( $this->post_type )
            && ! empty( $this->singular_name )
            && ! empty( $this->slug )
        );

    }
863432
protected function checkRequirements()
    {
        $required_properties = array('_buildFile');
        foreach ($required_properties as $required_property) {
            if (empty($this->$required_property)) {
                throw new \BuildException(
                    "Missing required property '" . $required_property . "'."
                );
            }
        }
    }
1005669
protected function areRequirementsMet(): bool
    {
        return ($this->token['code'] !== T_VARIABLE) || (new PropertyHelper($this->file))->isProperty($this->stackPos);
    }
1233769
final public function check()
	{
		if ( ! $this->perform_check())
		{
			\Auth::_unregister_verified($this);
			return false;
		}

		\Auth::_register_verified($this);
		return true;
	}
1020656
public final function verify(){

        foreach($this->definition as $k => $v){
            $this->verifyData($k);
        }//foreach

        if(count($this->errors)){
            return false;
        }//if

        return true;

    }
141544
public function check()
    {

        $config = $this->getConfig();

        if (isset($config['ext'])) {
            $this->setExt($config['ext']);
        }

        if (isset($config['folder'])) {

            $folder = $config['folder'];
            $this->setFolder($folder);


            if(!$this->getFileSystem()->exists($folder))
            {
                $this->getFileSystem()->createDir($folder);
                chmod($folder, 0777);
            }
        }else{

            return false;
        }

        // we have do something else

        if (function_exists('gzcompress') && function_exists('gzuncompress')) {
            return true;
        }
    }
35740
private function requiredSystemCommands()
    {

        // todo fix command existence in windows os
        return true;


        // Programs needed in $PATH
        $required_commands = ['git', 'rsync','php', 'composer'];

        $missing = [];
        foreach ($required_commands as $command) {
            $this->process->setCommandLine('which ' . $command);
            $this->process->setTimeout(null);
            $this->process->run();

            if (!$this->process->isSuccessful()) {
                $missing[] = $command;
            }
        }

        if (count($missing)) {
            asort($missing);

            $this->console->error('Commands not found: ' . implode(', ', $missing));
            $this->errors = true;
        }
    }
812452
public function needsToBeCaptured()
    {
        if (!$this->shouldBeCaptured()) {
            return false;
        }

        // computes the most recently completed period
        $mostRecentPeriod = $this->nthPreviousPeriod(1);

        // computes the start date for the most recently completed period
        $latestStartDate = date('Y-m-d', $mostRecentPeriod[ 'start' ]);

        // check if the metric has been saved before
        return Statistic::totalRecords([
            'metric' => $this->key(),
            'day' => $latestStartDate, ]) == 0;
    }
493571
public function verifySettings()
    {
        if ($this->targetdir === null) {
            $this->setError("The targetdir attribute is required.");
        }
        if ($this->mapperElement === null) {
            $this->map = new IdentityMapper();
        } else {
            $this->map = $this->mapperElement->getImplementation();
        }
        if ($this->map === null) {
            $this->setError("Could not set <mapper> element.");
        }
    }
846466
protected function validateInstallerInstall()
    {
        $field = 'installer';

        if ($this->isExcluded($field)) {
            return null;
        }

        $value = $this->getSubmitted($field);

        if (empty($value)) {
            $this->setSubmitted('installer', 'default');
            return null;
        }

        $installer = $this->install->getHandler($value);

        if (empty($installer)) {
            $this->setErrorInvalid('installer', $this->translation->text('Installer'));
            return false;
        }

        return true;
    }