add a route to the homepage

@param string $url       relative (to root) url to the service
@param string $schemaUrl relative (to root) url to the schema

@return void
545490
public function addRoute($url, $schemaUrl)
    {
        $this->addedRoutes[] = [
            '$ref' => $this->normalizeRelativeUrl($url),
            'profile' => $this->normalizeRelativeUrl($schemaUrl)
        ];
    }
851363
private function addBaseurl2AnchorUrls(&$filtered, $baseurl)
    {
        $textf   = $this->di->get("textfilter");
        $url     = $this->di->get("url");
        $request = $this->di->get("request");
        $part = $request->getRoute();

        // Use callback to url->create() instead of string concat
        $callback = function ($route) use ($url, $baseurl, $part) {
            if (!empty($route) && $route[0] == "!") {
                return $url->asset(substr($route, 1), $baseurl);
            }

            if (isset($route[0])
                && isset($route[1])
                && $route[0] === "."
                && $route[1] === "/"
            ) {
                return $url->create(
                    substr($route, 2),
                    $baseurl . $part
                );
            }

            return $url->create($route, $baseurl);
        };

        $filtered->text =
            $textf->addBaseurlToRelativeLinks($filtered->text, $baseurl, $callback);
    }
722042
public function updateURL(&$url) {
		if($this->owner instanceof \Image_Cached || $this->owner instanceof \CdnImage_Cached) {
			return; /** handled in @link ImageCachedExtension */
		}

        // in the CMS, we do _not_ change the asset
        $controller = Controller::has_curr() ? Controller::curr() : null;
        if ($controller instanceof LeftAndMain) {
            return;
        }

        if ($this->owner->CanViewType && $this->owner->getViewType() != CDNFile::ANYONE_PERM) {
            return;
        }

        $cdnLink = $this->getCdnLink();
        if ($cdnLink) {
            $url = $cdnLink;
        }
	}
431825
public void addSchema( String uri, IslandSchema s ) {
		if( schemata.containsKey(uri) )
			throw new IllegalArgumentException();
		schemata.put( uri, s );
	}
853848
public function initializeWithUrlAndRootPath($url, $root_path)
    {
        $this->initializeWithUrl($url);
        $this->root_path = $root_path;

        return $this;
    }
924924
private function setUrl() {

		$this -> url = Router :: url($this -> identifier, $this -> params, $this -> domain);

		$url = new URLParser($this -> url);

		if(null === $url -> getScheme() && strlen($this -> url) > 0) {
			$this -> url = '/' . $this -> url;
		}
	}
73104
function reroute($url=NULL,$permanent=FALSE) {
		if (preg_match('/^\/([^\/]*)/',$url,$m) && !array_key_exists($m[1],$this->languages))
			$url=rtrim('/'.$this->current.$url,'/');
		$this->f3->reroute($url,$permanent);
	}
112181
public function redirect($url, $header=301)
    {
        $this->disableLayout();
        $this->setNoRender();

        $this->_params["dispatcher"]->clearHeaders();
        $this->_params["dispatcher"]->addHeader("Location", $url, $header);
    }
108225
public function setUrl($url)
    {
        if ($this->hasBeenSent()) {
            throw new CAS_OutOfSequenceException(
                'Cannot set the URL, request already sent.'
            );
        }
        if (!is_string($url)) {
            throw new CAS_InvalidArgumentException('$url must be a string.');
        }

        $this->_url = $url;
    }
354320
public void addURL(final URL url) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				DynamicURLClassLoader.this.ucp.addURL(url);
				return null;
			}
		}, this.acc);
	}
1086077
public function setUrl( $url ) {
		if ( $url !== static::WILDCARD ) {
			$url = UrlUtility::addLeadingSlash( UrlUtility::addTrailingSlash( $url ) );
		}

		$this->url = $url;
	}
362597
private function loadSchema(string $schemaUrl): array
    {
        $options = [
            'http' => ['method' => 'GET'],
        ];
        $context = \stream_context_create($options);
        $schema = @\file_get_contents($schemaUrl, false, $context);

        if ($schema === false) {
            throw new LoadSchemaException($schemaUrl);
        }
        $schema = $this->utils->decode($schema);

        // resolve nested schema reference if needed
        if (stripos($schemaUrl, '#') !== false) {
            $schemaUrlParts = \explode('#', $schemaUrl);
            if (isset($schemaUrlParts[1]) && $schemaUrlParts[1] !== '') {
                $schemaRef = ['$ref' => \sprintf('#%s', $schemaUrlParts[1])];
                $resolver = new Resolver($schemaRef, $schema);
                $schema = $resolver->resolve();
            }
        }
        return $schema;
    }
14669
public function addUrl($name, $url)
    {
        $this->arguments[] = 'set-url';
        $this->arguments[] = '--add';
        $this->arguments[] = $name;
        $this->arguments[] = $url;
        return $this;
    }
491006
public static function setServerLoginURL($url = '')
    {
        phpCAS :: traceBegin();
        phpCAS::_validateClientExists();

        try {
            self::$_PHPCAS_CLIENT->setServerLoginURL($url);
        } catch (Exception $e) {
            phpCAS :: error(get_class($e) . ': ' . $e->getMessage());
        }

        phpCAS :: traceEnd();
    }
524341
public function addURLs($urls)
  {
    PHPCrawlerBenchmark::start("adding_urls_to_sqlitecache");

    $this->PDO->exec("BEGIN EXCLUSIVE TRANSACTION;");

    $cnt = count($urls);
    for ($x=0; $x<$cnt; $x++)
    {
      if ($urls[$x] != null)
      {
        $this->addURL($urls[$x]);
      }

      // Commit after 1000 URLs (reduces memory-usage)
      if ($x%1000 == 0 && $x > 0)
      {
        $this->PDO->exec("COMMIT;");
        $this->PDO->exec("BEGIN EXCLUSIVE TRANSACTION;");
      }
    }

    $this->PDO->exec("COMMIT;");
    $this->PreparedInsertStatement->closeCursor();

    if ($this->db_analyzed == false)
    {
      $this->PDO->exec("ANALYZE;");
      $this->db_analyzed = true;
    }

    PHPCrawlerBenchmark::stop("adding_urls_to_sqlitecache");
  }
344202
public static function add( $key, $path, $url = null )
	{
		static::$paths[$key] = $path;
		
		if ( !is_null( $url ) )
		{
			static::$urls[$key] = $url;
		}
	}
1073301
private function _setPathIfEmpty($url)
    {
        $path = parse_url($url, PHP_URL_PATH);

        if (empty($path)) {
            $this->setUrlPath('/');
        }
    }