Resolves the matching.

@return boolean Returns `true` if successfully resolved, `false` otherwise.
541600
public function resolve()
    {
        $startIndex = $this->_ordered ? Calls::lastFindIndex() : 0;
        $report = Calls::find($this->_messages, $startIndex, $this->times());
        $this->_report = $report;
        $this->_buildDescription($startIndex);
        return $report['success'];
    }
804939
public final boolean isResolved() {
		return getPathParameters().stream().filter(MessageParameter::isMandatory).allMatch(MessageParameter::isResolved)
			&& getQueryParameters().stream().filter(MessageParameter::isMandatory).allMatch(MessageParameter::isResolved);
	}
713121
public boolean resolve ()
    {
        // if we got canned before we were resolved, go ahead and bail now
        if (_panel != null) {
            if (_panel.getBlock(_bounds.x, _bounds.y) != this) {
                // Log.info("Not resolving abandoned block " + this + ".");
                _wasAbandoned = true;
                return false;
            }
            _panel.blockResolving(this);
        }
        // We're doing our work, we're needed!
        _wasAbandoned = false;

        // start with the bounds of the footprint polygon
        Rectangle sbounds = new Rectangle(_footprint.getBounds());
        Rectangle obounds = null;

        // resolve our base tiles
        long now = System.currentTimeMillis();
        int baseCount = 0, fringeCount = 0;
        for (int yy = 0; yy < _bounds.height; yy++) {
            for (int xx = 0; xx < _bounds.width; xx++) {
                int x = _bounds.x + xx, y = _bounds.y + yy;
                int fqTileId = _model.getBaseTileId(x, y);
                if (fqTileId <= 0) {
                    continue;
                }

                // load up this base tile
                updateBaseTile(fqTileId, x, y);
                baseCount++;

                // if there's no tile here, we don't need no fringe
                int tidx = index(x, y);
                if (_base[tidx] == null) {
                    continue;
                }

                // compute the fringe for this tile
                _fringe[tidx] = computeFringeTile(x, y);
                fringeCount++;
            }
        }

        // DEBUG: check for long resolution times
        long stamp = System.currentTimeMillis();
        long elapsed = stamp - now;
        if (elapsed > 500L) {
            log.warning("Base and fringe resolution took long time " +
                        "[block=" + this + ", baseCount=" + baseCount +
                        ", fringeCount=" + fringeCount +
                        ", elapsed=" + elapsed + "].");
        }

        // resolve our objects
        ObjectSet set = new ObjectSet();
        _model.getObjects(_bounds, set);
        ArrayList<SceneObject> scobjs = Lists.newArrayList();
        now = System.currentTimeMillis();
        for (int ii = 0, ll = set.size(); ii < ll; ii++) {
            SceneObject scobj = makeSceneObject(set.get(ii));
            // ignore this object if it failed to resolve
            if (scobj.bounds == null) {
                continue;
            }
            sbounds.add(scobj.bounds);
            obounds = GeomUtil.grow(obounds, scobj.bounds);
            scobjs.add(scobj);

            // DEBUG: check for long resolution times
            stamp = System.currentTimeMillis();
            elapsed = stamp - now;
            now = stamp;
            if (elapsed > 250L) {
                log.warning("Scene object took look time to resolve " +
                            "[block=" + this + ", scobj=" + scobj +
                            ", elapsed=" + elapsed + "].");
            }
        }
        _objects = scobjs.toArray(new SceneObject[scobjs.size()]);

        // resolve our default tileset
        int bsetid = _model.getDefaultBaseTileSet();
        try {
            if (bsetid > 0) {
                _defset = _tileMgr.getTileSet(bsetid);
            }
        } catch (Exception e) {
            log.warning("Unable to fetch default base tileset [tsid=" + bsetid +
                        ", error=" + e + "].");
        }

        // this both marks us as resolved and makes all our other updated
        // fields visible
        synchronized (this) {
            _obounds = obounds;
            _sbounds = sbounds;
        }

        return true;
    }
427114
public static function resolve(){

        $aArgs = func_get_args();

        $aDebug = debug_backtrace(1);

        if(isset($aDebug[1])){

            $oDebug = $aDebug[1];

            $function = $oDebug['function'];
            $class = $oDebug['class'];

            if(!empty($aArgs)){
                $args = $aArgs;
            } else {
                $args = $oDebug['args'];
            }

            $app = $class::getFacadeApplication();

            return call_user_func_array( array($app[$class::getFacadeAccessor()], $function), $args);
        } else {
            Throw new \Exception('Cannot resolve this function');
        }
    }
177704
public function resolve()
    {
        $this->data = [
            'environment' => php_sapi_name(),
            'process-id' => $this->process->getId(),
            'parent-process-id' => $this->process->getParentId(),
            'date' => date('Y-m-d'),
            'time' => date('H:m:s'),
            'timestamp' => time()
        ];
    }
1192574
public function accept()
    {
        $asset = $this->getInnerIterator()->current(true);
        $duplicate = false;

        // check strict equality
        if (in_array($asset, $this->visited, true)) {
            $duplicate = true;
        } else {
            $this->visited[] = $asset;
        }

        // check source
        $sourceRoot = $asset->getSourceRoot();
        $sourcePath = $asset->getSourcePath();
        if ($sourceRoot && $sourcePath) {
            $source = $sourceRoot.'/'.$sourcePath;
            if (in_array($source, $this->sources)) {
                $duplicate = true;
            } else {
                $this->sources[] = $source;
            }
        }

        return !$duplicate;
    }
817770
protected function matchRoute()/*# : bool */
    {
        foreach ($this->getCollectors() as $coll) {
            if ($coll->matchRoute($this->result)) {
                return true;
            }
        }
        return false;
    }
472243
protected function _matchType()
    {
        if (!$this->_types) {
            return true;
        }
        $file = $this->current();
        foreach ($this->_types as $type) {
            $method = 'is' . ucfirst($type);
            if ($file->$method()) {
                return true;
            }
        }
        return false;
    }
454010
public function match($actual)
    {
        $this->actual = $actual;

        return ($actual >= $this->start && $actual <= $this->end);
    }
1133528
public function process()
    {
        if (!$this->_processed) {
            $this->_process();
            $this->_resolve();
        }
        $this->_processed = true;
        return $this->_passed !== false;
    }
1082265
public function resolve()
    {
        // TODO: Make this dynamic.

        if (is_scalar($this->value)) {
            if (is_string($this->value)) {
                return ScalarTypes::SCALAR_STRING;
            } elseif (is_bool($this->value)) {
                return ScalarTypes::SCALAR_BOOLEAN;
            } elseif (is_integer($this->value)) {
                return ScalarTypes::SCALAR_INTEGER;
            } elseif (is_float($this->value)) {
                return ScalarTypes::SCALAR_FLOAT;
            }
        } elseif (is_array($this->value)) {
            return CompoundTypes::COMPOUND_ARRAY;
        } elseif (is_object($this->value)) {
            return CompoundTypes::COMPOUND_OBJECT;
        } elseif (is_resource($this->value)) {
            return SpecialTypes::SPECIAL_RESOURCE;
        } elseif ($this->value === null) {
            return SpecialTypes::SPECIAL_NULL;
        }

        throw new UnknownTypeException(gettype($this->value));
    }
345860
public function match(){

            $session = $this->getSession();
            $key = static::USER_SESSION;
            if($session->has($key)){

                if($value = $session->get($key) instanceof AuthenticationLoginObject){
                    return $value;
                }
            }else{
                return false;
            }
        }
248242
public function accept()
	{
		if( $this->getInnerIterator()->isDot() )
			return FALSE;
		$isDir	= $this->getInnerIterator()->isDir();
		if( !$this->showFolders && $isDir ) 
			return FALSE;
		if( !$this->showFiles && !$isDir ) 
			return FALSE;

		if( $this->stripDotEntries )
		{
			$folderName	= $this->getInnerIterator()->getFilename();
			if( preg_match( "@^\.\w@", $folderName ) )
				return FALSE;
		}
		return TRUE;
	}
1073316
public function accept()
    {
        $query = $this->getInnerIterator()->current();
        $pattern = $this->isRegex($this->statement) ? $this->statement : '/^' . $this->statement . '/i';
        if (!preg_match($pattern, $query[0])) {
            return false;
        }

        return true;
    }
20527
public function accept()
    {
        if ($this->isRecursive && isset($this->excludedDirs[$this->getFilename()]) && $this->isDir()) {
            return false;
        }

        if ($this->excludedPattern) {
            $path = $this->isDir() ? $this->current()->getRelativePathname() : $this->current()->getRelativePath();
            $path = str_replace('\\', '/', $path);

            return !preg_match($this->excludedPattern, $path);
        }

        return true;
    }
437286
public function condition_matches() {
        $match = false; // By default no match
        $param = $this->procconditionparam;
        if ($param instanceof base_atom && $param->is_set()) {
            $match = ($param->get_value() == $this->conditionvalue); // blame $DB for not having === !
        } else {
            $match = ($param == $this->conditionvalue);
        }
        return $match;
    }
769462
public function resolve(): string
    {
        $packageType = $this->composer->getPackage()->getType();
        return array_key_exists($packageType, $this->mapping)
            ? $this->mapping[$packageType]
            : 'default';
    }