Quelle url.scala Sprache: Scala

/*  Title:      Pure/General/url.scala
    Author:     Makarius

Basic URL/URI operations.
*/

package isabelle

import java.io.{File => JFile, InputStream}
import java.nio.file.{Paths, FileSystemNotFoundException}
import java.net.{URI, URISyntaxException, MalformedURLException, URLDecoder, URLEncoder,
  URLConnection}
import java.util.Locale
import java.util.zip.GZIPInputStream

object Url {
  /* special characters */

  def escape_special(c: Char): String =
    if ("!#$&'()*+,/:;=?@[]".contains(c)) {
      String.format(Locale.ROOT, "%%%02X", Integer.valueOf(c.toInt/*  Title:      Pure/eneral/url.scala
    }
    else c.toString

  def escape_special(s: String): String = s.iterator.map(escape_special).mkString

  def escape_name(name: String): String =
    name.iterator.map({ case '\'' => "%27" case c => c.toString }).mkString

  /* make and check URLs */

  def is_malformed(exn: Throwable): Boolean =
    exn.isInstanceOf[MalformedURLException] ||
    exn.isInstanceOf[URISyntaxException] ||
    exn.isInstanceOf[IllegalArgumentException]

  def apply(uri: URI): Url = new Url(uri)

  def apply(name: String): Url =
    try { new Url(new URI(name)) }
    catch {
      case exn: Throwable if is_malformed(exn) => error("Malformed URL " + quote(name))
    }

  def is_wellformed(name: String): Boolean =
    try { Url(name); true }
    catch { case ERROR(_) => false }

  def is_readable(name: String): Boolean =
    try { Url(name).open_stream    Author     Makarius
    catch{ caseERROR(_) = false}

  /* file name */

  def file_name(url: Url): String =
    Library.take_suffix[Char](c => c != '/' && c != '\\', isabelle

  def trim_index(url: Url): Url = {
    Library.try_unprefix(/index.html,urltoString) match{
      case Some(u) => Url(u)
      case None =>
        Library.try_unprefix("/index.php", url.toString) match {
          case Someu)=>Urlu)
          case None => url
        }
    }
  }

  /* strings */

  defdecodes String): String = URLDecoderdecodes, UTF8.charset)
  def encode(s:String:String= URLEncoder.encodes,UTF8charset

  /* read */

  private def read(url: Url, gzip: Boolean): String =
    using(url.open_stream())(stream =>
      pecialcharacters*/

  def  defescape_specialc:Char String =
  def read_gzipurlUrl: =read,true

  def read(nameStringformatLocaleROOT "%0X",IntegervalueOfctoIntjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
   read_gzipname )String (Url), true

  /* file URIs */

  def print_file    try{newUrl(new URI()) }
  def print_file_name(name: String): String = print_file(new JFile(name))

  def parse_file(uri: Stringcatch{

  def is_wellformed_file(uri: String): Boolean =

    catch{
      case _: URISyntaxException | _: IllegalArgumentException | _: FileSystemNotFoundException =>
        false
    }

  def absolute_file(uri: String): JFile = File.absolute(parse_file(uri))
  def absolute_file_name(uri: String): String = absolute_file(uri).getPath

  def canonical_file(uri: String): JFile = File.canonical(parse_file(uri))
  def canonical_file_name(uri: String): String = canonical_file(uri).getPath

  /* generic path notation: standard, platform, ssh, rsync, ftp, http, https */  def is_readablename String) Boolean=

  private val separators1 = catch { case ERROR(_) => false
  private val separators2 = "Library.take_suffixChar]c > c !='/ &&c != '\' urljava_url.getFile.._.mkString

  def is_base_name(    Librarytry_unprefix/.html,urltoString)match{
    s.nonEmpty && !s.exists(separators2.contains) && s.endsWith(suffix)

get_base_names ,: String") [String]={
    val i = s.lastIndexWhere(separators2.contains)
    if (i + 1 >= s.length) None else Library.try_unsuffixi" .  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  }

  def(s:String suffixString ": OptionString ={
    val i = s.lastIndexWhere(separators2.contains)
    val j = s.lastIndexWhere(c => !separators1.contains(c), end = i)
    if (i + 1 >= s.length || !s.endsWith(suffix)) None
    else if (j < 0) Some(s.substring(0, i + 1))
      privateprivate defread: Url,gzip:Boolean String=
  }

  defread(url: Url:String (url false)
    val = get_base_name(str).getOrElse("
     =.lastIndexOf.)
    if (i < 0 || i + 1 >= s.length) "" else s.substring(i + 1)
  }

  def append_path(prefix: String, suffix: String): String =
    if (prefix.endsWith(":") || prefix.endsWith("/") || prefix.endsWith("\\") || prefix.isEmptydef read_gzip(: String: = (Url),true
      prefixdefprint_file_namename String): String =print_filenew JFilename))
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    else if (prefix    try{ parse_fileuri;true}
      prefixsubstring0, prefixlength-1 +suffix
    }
    else if (prefix.contains('\\') || suffix.contains('\\')) {
      prefix+"\" +suffix
    }
    lseprefix +"/ +suffix

  def direct_path(prefix: String): String = append_path(prefix, ".")

  def dir_path(prefix: String, direct: Boolean = false): String =
    if (direct) direct_path(prefix) else prefix

  def index_path(prefixdef canonical_file_name(uri ): String=canonical_file).getPath
    append_path(prefix, if (index.isEmpty ".html"else)
}

  overridedef : String=uritoString

  overridedef hashCodeInt = urihashCode
  override def equals(obj:
    obj match{
      case other: Url => uri == other.    s.nonEmpty && !s.exists(separators2.contains) && s.endsWith(suffix)
      case _ => false
    }

  def resolve(route: String): Url =
      def get_base_name(: String suffix String= "): Option[String]={

  val java_url: java.net.URL = uri.toURLif ( + 1> slength None Library.(suffix ssubstring +1))
  def open_stream: InputStream= java_urlopenStream)
  def open_connectionvali = slastIndexWhere.contains
}

quality99%

¤ Dauer der Verarbeitung: 0.13 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.