/**
   * Gets the destination of a redirection
   *
   * @return absolute URL of new location; null if not available
   */
  static URI getLocation(HttpRequest request, HttpResponse response, HttpContext context) {
    Header locationHdr = response.getFirstHeader("Location");
    if (locationHdr == null) {
      Log.e(TAG, "Received redirection without Location header, ignoring");
      return null;
    }
    try {
      URI location = URIUtils.parseURI(locationHdr.getValue(), false);

      // some servers don't return absolute URLs as required by RFC 2616
      if (!location.isAbsolute()) {
        Log.w(TAG, "Received invalid redirection to relative URL, repairing");
        URI originalURI = URIUtils.parseURI(request.getRequestLine().getUri(), false);
        if (!originalURI.isAbsolute()) {
          final HttpHost target = HttpClientContext.adapt(context).getTargetHost();
          if (target != null)
            originalURI = org.apache.http.client.utils.URIUtilsHC4.rewriteURI(originalURI, target);
          else return null;
        }
        return originalURI.resolve(location);
      }
      return location;
    } catch (URISyntaxException e) {
      Log.e(TAG, "Received redirection from/to invalid URI, ignoring", e);
    }
    return null;
  }
  public InputStream openResource(URI uri) throws IOException {
    if (uri.isAbsolute() && uri.getScheme().equals("file")) {
      try {
        return uri.toURL().openStream();
      } catch (Exception except) {
        log.error("openResource: unable to open file URL " + uri + "; " + except.toString());
        return null;
      }
    }

    // Note that if we get an absolute URI, the relativize operation will simply
    // return the absolute URI.
    URI relative = baseUri.relativize(uri);

    if (relative.isAbsolute() && relative.getScheme().equals("http")) {
      try {
        return relative.toURL().openStream();
      } catch (Exception except) {
        log.error("openResource: unable to open http URL " + uri + "; " + except.toString());
        return null;
      }
    }

    if (relative.isAbsolute() && !relative.getScheme().equals("urn")) {
      log.error("openResource: invalid scheme (should be urn:)  " + uri);
      return null;
    }

    File f = new File(baseUri.getPath(), relative.getPath());
    if (!f.exists()) {
      log.error("openResource: file not found " + f);
      return null;
    }
    return new FileInputStream(f);
  }
  /**
   * Resolve a source uri against a target.
   *
   * @param sourcePartUri The source URI.
   * @param targetUri The target URI.
   * @return The resolved URI.
   */
  public static URI resolvePartUri(URI sourcePartUri, URI targetUri) {
    if (sourcePartUri == null || sourcePartUri.isAbsolute()) {
      throw new IllegalArgumentException("sourcePartUri invalid - " + sourcePartUri);
    }

    if (targetUri == null || targetUri.isAbsolute()) {
      throw new IllegalArgumentException("targetUri invalid - " + targetUri);
    }

    return sourcePartUri.resolve(targetUri);
  }
  private void testUri(String input) {
    URI uri = new UriBuilderImpl().uri(input).clone().build();

    URI originalUri = URI.create(input);
    assertEquals(originalUri.getScheme(), uri.getScheme());
    assertEquals(originalUri.getHost(), uri.getHost());
    assertEquals(originalUri.getPort(), uri.getPort());
    assertEquals(originalUri.getUserInfo(), uri.getUserInfo());
    assertEquals(originalUri.getPath(), uri.getPath());
    assertEquals(originalUri.getQuery(), uri.getQuery());
    assertEquals(originalUri.getFragment(), uri.getFragment());
    assertEquals(originalUri.getRawSchemeSpecificPart(), uri.getRawSchemeSpecificPart());
    assertEquals(originalUri.isAbsolute(), uri.isAbsolute());
    assertEquals(input, uri.toString());
  }
  private String parseURI(URI uri) {
    if (!uri.isAbsolute()) {
      throw new IllegalArgumentException(uri + " is not an absolute URI");
    }

    return uri.isOpaque() ? parseOpaqueURI(uri) : parseHierarchicalURI(uri);
  }
Exemple #6
0
 /**
  * Get Base64 encoding content. For ODT transformation
  *
  * @param dirName - The directory name that will be added to the path of the image file.
  * @param fileName - The file name of the image file.
  * @return base64 encoded binary data.
  */
 public static String getBASE64(final String dirName, final String fileName) {
   final DITAOTJavaLogger logger = new DITAOTJavaLogger();
   final URI imgInputURI = toURI(fileName);
   final File imgInput =
       imgInputURI.isAbsolute()
           ? new File(imgInputURI)
           : new File(dirName, toFile(imgInputURI).getPath());
   // BASE64Encoder encoder = new BASE64Encoder();
   final Base64 encoder = new Base64();
   final byte buff[] = new byte[(int) imgInput.length()];
   FileInputStream file = null;
   try {
     file = new FileInputStream(imgInput);
     file.read(buff);
     // String ret = encoder.encode(buff);
     return encoder.encodeToString(buff);
   } catch (final FileNotFoundException e) {
     logger.error(MessageUtils.getInstance().getMessage("DOTJ023E").toString());
     logger.error(e.getMessage(), e);
     return null;
   } catch (final IOException e) {
     logger.error(MessageUtils.getInstance().getMessage("DOTJ023E").toString());
     logger.error(e.getMessage(), e);
     return null;
   } finally {
     if (file != null) {
       try {
         file.close();
       } catch (final IOException ioe) {
         logger.error(ioe.getMessage(), ioe);
       }
     }
   }
 }
 /*  43:    */
 /*  44:    */ private ModuleSource loadFromPathArray(
     String moduleId, Scriptable paths, Object validator)
     /*  45:    */ throws IOException
       /*  46:    */ {
   /*  47: 60 */ long llength =
       ScriptRuntime.toUint32(ScriptableObject.getProperty(paths, "length"));
   /*  48:    */
   /*  49:    */
   /*  50: 63 */ int ilength = llength > 2147483647L ? 2147483647 : (int) llength;
   /*  51: 66 */ for (int i = 0; i < ilength; i++)
   /*  52:    */ {
     /*  53: 67 */ String path =
         ensureTrailingSlash((String) ScriptableObject.getTypedProperty(paths, i, String.class));
     /*  54:    */ try
     /*  55:    */ {
       /*  56: 70 */ URI uri = new URI(path);
       /*  57: 71 */ if (!uri.isAbsolute()) {
         /*  58: 72 */ uri = new File(path).toURI().resolve("");
         /*  59:    */ }
       /*  60: 74 */ ModuleSource moduleSource =
           loadFromUri(uri.resolve(moduleId), uri, validator);
       /*  61: 76 */ if (moduleSource != null) {
         /*  62: 77 */ return moduleSource;
         /*  63:    */ }
       /*  64:    */ }
     /*  65:    */ catch (URISyntaxException e)
     /*  66:    */ {
       /*  67: 81 */ throw new MalformedURLException(e.getMessage());
       /*  68:    */ }
     /*  69:    */ }
   /*  70: 84 */ return null;
   /*  71:    */ }
 /**
  * Working on behalf of the given source factory, resolve the (possibly relative) contained URI
  * against the URI associated with the containing source object. Return a {@link Source source}
  * representing the file to which it was resolved, or {@code null} if it could not be resolved.
  *
  * @param factory the source factory requesting the resolution of the URI
  * @param containingSource the source containing the given URI
  * @param containedUri the (possibly relative) URI to be resolved against the containing source
  * @return a {@link Source source} representing the URI to which given URI was resolved
  */
 public Source resolve(SourceFactory factory, Source containingSource, URI containedUri) {
   if (containedUri.isAbsolute()) {
     return resolveAbsolute(factory, containedUri);
   } else {
     return resolveRelative(factory, containingSource, containedUri);
   }
 }
Exemple #9
0
  public static URI build(URI prefix, URI localName) throws NamingAuthorityConfigurationException {
    try {
      verifyPrefix(prefix);
    } catch (Exception e) {
      throw new NamingAuthorityConfigurationException(e.getMessage());
    }

    if (localName == null) {
      throw new IllegalArgumentException("Localname must not be null.");
    } else if (localName.isAbsolute()) {
      throw new IllegalArgumentException("Localname must be a relative URI.");
    }

    // request.getPathInfo() strips required "/" from identifier URL, replace it
    String scheme = localName.getScheme();
    String path = localName.getPath();
    // trim off any leading / so the URI resolving doesn't treat it as an
    // absolute path
    if (path.startsWith("/")) {
      path = path.substring(1);
    }
    String url = path;
    if (scheme != null) {
      url = scheme + ":/" + path;
    }
    localName = URI.create(url);

    return prefix.resolve(localName);
  }
Exemple #10
0
 public InputSource(URI uri) {
   if (!uri.isAbsolute()) {
     throw new IllegalArgumentException(uri.toString());
   }
   this.uri = uri;
   this.uriStr = uri.toString();
 }
 /**
  * Creates absolute request URI with full path from passed in context, honoring proxy if in play.
  */
 @Nonnull
 private URI getRequestURI(final HttpContext context) {
   final HttpClientContext clientContext = HttpClientContext.adapt(context);
   final HttpRequest httpRequest = clientContext.getRequest();
   try {
     URI uri;
     if (httpRequest instanceof HttpUriRequest) {
       uri = ((HttpUriRequest) httpRequest).getURI();
     } else {
       uri = URI.create(httpRequest.getRequestLine().getUri());
     }
     final RouteInfo routeInfo = clientContext.getHttpRoute();
     if (routeInfo != null) {
       if (routeInfo.getHopCount() == 1 && uri.isAbsolute()) {
         return uri;
       }
       HttpHost target = routeInfo.getHopTarget(0);
       return URIUtils.resolve(URI.create(target.toURI()), uri);
     } else {
       return uri;
     }
   } catch (Exception e) {
     log.warn("Could not create absolute request URI", e);
     return URI.create(clientContext.getTargetHost().toURI());
   }
 }
  /*
   * InputStream must be closed
   * (non-Javadoc)
   * @see org.eclipse.equinox.simpleconfigurator.manipulator.SimpleConfiguratorManipulator#loadConfiguration(java.io.InputStream, java.net.URI)
   */
  public BundleInfo[] loadConfiguration(InputStream stream, URI installArea) throws IOException {
    if (stream == null) return NULL_BUNDLEINFOS;

    List simpleBundles = SimpleConfiguratorUtils.readConfiguration(stream, installArea);

    // convert to FrameworkAdmin BundleInfo Type
    BundleInfo[] result = new BundleInfo[simpleBundles.size()];
    int i = 0;
    for (Iterator iterator = simpleBundles.iterator(); iterator.hasNext(); ) {
      org.eclipse.equinox.internal.simpleconfigurator.utils.BundleInfo simpleInfo =
          (org.eclipse.equinox.internal.simpleconfigurator.utils.BundleInfo) iterator.next();
      URI location = simpleInfo.getLocation();
      if (!location.isAbsolute() && simpleInfo.getBaseLocation() != null)
        location = URIUtil.makeAbsolute(location, simpleInfo.getBaseLocation());

      BundleInfo bundleInfo =
          new BundleInfo(
              simpleInfo.getSymbolicName(),
              simpleInfo.getVersion(),
              location,
              simpleInfo.getStartLevel(),
              simpleInfo.isMarkedAsStarted());
      bundleInfo.setBaseLocation(simpleInfo.getBaseLocation());
      result[i++] = bundleInfo;
    }
    return result;
  }
Exemple #13
0
  public CssUrlRewriter(File cssBasePath, final CharSequence input)
      throws BundlerProcessingException {
    Matcher urlMatcher = URL_PATTERN.matcher(input);
    while (urlMatcher.find()) {
      String relativePath = urlMatcher.group(1);
      // this is used to ignore any spacing so can be read as a URI correctly.
      String withoutSpacesOrNewLines = relativePath.replaceAll("(\\s)", "");

      boolean parsableUrl = true;
      try {
        /* if it parses as a URI don't rewrite */
        URI uri = new URI(withoutSpacesOrNewLines);
        if (uri.isAbsolute()) {
          parsableUrl = false;
        }
      } catch (URISyntaxException ex) {
        throw new RuntimeException(
            "URI \"" + relativePath + "\" is invalid (" + ex.getReason() + ").", ex);
      }

      if (parsableUrl) {
        String parsedUrl = parseUrl(cssBasePath, relativePath);
        urlMatcher.appendReplacement(css, parsedUrl);
      }
    }
    urlMatcher.appendTail(css);
  }
Exemple #14
0
 private static void construct(String str, String host, String path, boolean absolute)
     throws URISyntaxException {
   URI uri = new URI(str);
   assertEquals(host, uri.getHost());
   assertEquals(path, uri.getPath());
   assertEquals(absolute, uri.isAbsolute());
 }
 private Uri resolveUri(URI uri) {
   if (uri.isAbsolute() || absoluteUri == null) {
     return convertToAndroidUriAndFixScheme(uri, uri);
   } else {
     return convertToAndroidUriAndFixScheme(absoluteUri.resolve(uri), absoluteUri);
   }
 }
Exemple #16
0
 @Deprecated
 public void setResourceURL(URI url) {
   if (!url.isAbsolute()) {
     throw new IllegalArgumentException("URL is not absolute: " + url);
   }
   this.url = url.toString();
 }
Exemple #17
0
 @Override
 public ILayer createLayer(URI source) throws LayerException {
   if (!source.isAbsolute()) {
     // If URI is not absolute ex URI.create("../folder/myfile.shp"), then create a canonical URI
     try {
       source =
           new File(location != null ? new File(location) : new File("./"), source.toString())
               .getCanonicalFile()
               .toURI();
     } catch (IOException ex) {
       throw new LayerException(ex);
     }
   }
   String layerName;
   try {
     layerName = FileUtils.getNameFromURI(source);
   } catch (UnsupportedOperationException ex) {
     try {
       layerName = dataManager.findUniqueTableName(I18N.tr("Layer"));
     } catch (SQLException ex2) {
       throw new LayerException(ex2);
     }
   }
   return createLayer(layerName, source);
 }
  public String getAbsolutePath(String path) {
    try {
      URI uri = new URI(path);
      if (uri.isAbsolute()) {
        return path;
      }
    } catch (URISyntaxException e) {
    }

    if (this.base != null && !this.base.equals("")) // $NON-NLS-1$
    {
      return makeAbsolute(base, path);
    }

    String result = path;
    Catalog catalog = (Catalog) getOwnerCatalog();
    if (catalog != null) {
      String base = catalog.getBase();
      if (base == null || base.equals("")) // $NON-NLS-1$
      {
        base = catalog.getLocation();
      }
      result = makeAbsolute(base, path);
    }
    return result;
  }
Exemple #19
0
  private static URI resolveUri(String uriStr, URI baseUri) throws URISyntaxException {
    URI resolved;

    URI resourceUri = new URI(uriStr);
    if (resourceUri.isAbsolute()) resolved = resourceUri;
    else resolved = baseUri.resolve(resourceUri);

    return resolved;
  }
  private static URI getEffectiveURI(HttpRequest httpRequest) {
    URI requestURI = URI.create(httpRequest.getUri());
    if (requestURI.isAbsolute()) {
      return requestURI;
    }

    String host = getHost(httpRequest);
    return (host != null) ? URI.create(format("http://%s%s", host, requestURI)) : null;
  }
Exemple #21
0
 /**
  * Set the absolute URI of the ultimate request that was made to receive this response.
  *
  * <p>If the original request URI has been modified (e.g. due to redirections), the absolute URI
  * of the ultimate request being made to receive the response should be set by the caller on the
  * response instance using this method.
  *
  * @param uri absolute URI of the ultimate request made to receive this response. Must not be
  *     {@code null}.
  * @throws java.lang.NullPointerException in case the passed {@code uri} parameter is null.
  * @throws java.lang.IllegalArgumentException in case the passed {@code uri} parameter does not
  *     represent an absolute URI.
  * @see ClientProperties#FOLLOW_REDIRECTS
  * @see #getResolvedRequestUri()
  * @since 2.6
  */
 public void setResolvedRequestUri(final URI uri) {
   if (uri == null) {
     throw new NullPointerException(LocalizationMessages.CLIENT_RESPONSE_RESOLVED_URI_NULL());
   }
   if (!uri.isAbsolute()) {
     throw new IllegalArgumentException(
         LocalizationMessages.CLIENT_RESPONSE_RESOLVED_URI_NOT_ABSOLUTE());
   }
   this.resolvedUri = uri;
 }
 /**
  * Creates a URI contatenating the specified {@code base} and {@code relativeUri}.
  *
  * @param base the URI base
  * @param relativeUri the uri
  * @return the final URI used to make the request
  * @throws URISyntaxException if the given string violates RFC 2396
  */
 default URI createUri(final String base, final String relativeUri) throws URISyntaxException {
   URI uri = new URI(relativeUri);
   if (!uri.isAbsolute()) {
     String uriBase = base;
     if (!uriBase.endsWith("/") && !relativeUri.startsWith("/")) {
       uriBase += "/";
     }
     uri = new URI(uriBase + relativeUri);
   }
   return uri;
 }
Exemple #23
0
  protected static String resolveIfRelative(String base, URI toResolve) {
    if (toResolve.isAbsolute()) {
      return toResolve.toString();
    }

    try {
      return new URI(base).resolve(toResolve).toString();
    } catch (URISyntaxException e) {
      throw new IllegalArgumentException(e);
    }
  }
Exemple #24
0
  /**
   * Returns results from parsing a {@link java.net.URI} with this pattern. If the URI doesn't match
   * the pattern, this will return null.
   *
   * @param uri A URI to match against this URIPattern
   * @return A Map of the pattern's variable names to values from the parsed URI
   */
  public Map<String, String> getMatch(URI uri) {
    // verify that the schemes match
    if (pattern.isAbsolute()) {
      // if there should be a scheme, make sure it matches
      if (!pattern.getScheme().equalsIgnoreCase(uri.getScheme())) {
        return null;
      }
    } else if (uri.getScheme() != null) {
      return null;
    }

    Map<String, String> result = Maps.newLinkedHashMap(defaults);

    if (pattern.isOpaque()) {
      if (!uri.isOpaque()) {
        return null;
      }

      Iterator<String> pathQuery =
          PATH_QUERY_SPLITTER.split(uri.getRawSchemeSpecificPart()).iterator();

      if (!addPath(patternPath, Iterators.getNext(pathQuery, null), result)) {
        return null;
      }

      addQuery(Iterators.getNext(pathQuery, null), result);

    } else if (!uri.isOpaque()) {
      addAuthority(uri, result);

      if (patternPath.isEmpty() && !uri.getRawPath().isEmpty()) {
        return null;
      }

      if (!addPath(patternPath, uri.getRawPath(), result)) {
        return null;
      }

      addQuery(uri.getRawQuery(), result);

    } else {
      return null;
    }

    if (!addComplexMatch(pattern.getFragment(), uri.getFragment(), result)) {
      return null;
    }

    // save this match
    this.lastMatch = result;

    // return the new result, so that this is thread-safe
    return result;
  }
Exemple #25
0
 /**
  * Recursive function to parse a layer tree
  *
  * @param lt
  * @param parentLayer
  */
 private void parseJaxbLayer(LayerType lt, ILayer parentLayer) throws LayerException {
   // Test if lt is a group
   if (!lt.getLayer().isEmpty() || (lt.getDataURL() == null)) {
     // it will create a LayerCollection
     parseJaxbLayerCollection(lt, parentLayer);
   } else {
     // it corresponding to a leaf layer
     // We need to read the data declaration and create the layer
     URLType dataUrl = lt.getDataURL();
     if (dataUrl != null) {
       OnlineResourceType resType = dataUrl.getOnlineResource();
       try {
         URI layerURI = new URI(resType.getHref());
         // The resource is given as relative to MapContext location
         if (!layerURI.isAbsolute() && getLocation() != null) {
           try {
             // Resolve the relative resource ex: new Uri("myFile.shp")
             layerURI = getLocation().resolve(layerURI);
           } catch (IllegalArgumentException ex) {
             LOGGER.warn(
                 "Error while trying to find an absolute path for an external resource", ex);
           }
         }
         // Get table name
         ILayer leafLayer = createLayer(layerURI);
         leafLayer.setDescription(new Description(lt));
         leafLayer.setVisible(!lt.isHidden());
         // Parse styles
         if (lt.isSetStyleList()) {
           for (StyleType st : lt.getStyleList().getStyle()) {
             if (st.isSetSLD()) {
               if (st.getSLD().isSetAbstractStyle()) {
                 leafLayer.addStyle(
                     new Style(
                         (JAXBElement<net.opengis.se._2_0.core.StyleType>)
                             st.getSLD().getAbstractStyle(),
                         leafLayer));
               }
             }
           }
         }
         parentLayer.addLayer(leafLayer);
       } catch (URISyntaxException ex) {
         throw new LayerException(
             I18N.tr("Unable to parse the href URI {0}.", resType.getHref()), ex);
       } catch (InvalidStyle ex) {
         throw new LayerException(
             I18N.tr("Unable to load the description of the layer {0}", lt.getTitle().toString()),
             ex);
       }
     }
   }
 }
Exemple #26
0
  protected Message createMessage(
      Object body,
      String httpMethod,
      MultivaluedMap<String, String> headers,
      URI currentURI,
      Exchange exchange,
      Map<String, Object> invocationContext,
      boolean proxy) {
    Message m = cfg.getConduitSelector().getEndpoint().getBinding().createMessage();
    m.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
    m.put(Message.INBOUND_MESSAGE, Boolean.FALSE);

    m.put(Message.HTTP_REQUEST_METHOD, httpMethod);
    m.put(Message.PROTOCOL_HEADERS, headers);
    if (currentURI.isAbsolute() && currentURI.getScheme().startsWith(HTTP_SCHEME)) {
      m.put(Message.ENDPOINT_ADDRESS, currentURI.toString());
    } else {
      m.put(Message.ENDPOINT_ADDRESS, state.getBaseURI().toString());
    }

    Object requestURIProperty = cfg.getRequestContext().get(Message.REQUEST_URI);
    if (requestURIProperty == null) {
      m.put(Message.REQUEST_URI, currentURI.toString());
    } else {
      m.put(Message.REQUEST_URI, requestURIProperty.toString());
    }

    m.put(Message.CONTENT_TYPE, headers.getFirst(HttpHeaders.CONTENT_TYPE));

    body = checkIfBodyEmpty(body);
    setEmptyRequestPropertyIfNeeded(m, body);

    m.setContent(List.class, getContentsList(body));

    m.put(URITemplate.TEMPLATE_PARAMETERS, getState().getTemplates());

    PhaseInterceptorChain chain = setupOutInterceptorChain(cfg);
    chain.setFaultObserver(setupInFaultObserver(cfg));
    m.setInterceptorChain(chain);

    exchange = createExchange(m, exchange);
    exchange.put(Message.REST_MESSAGE, Boolean.TRUE);
    exchange.setOneWay("true".equals(headers.getFirst(Message.ONE_WAY_REQUEST)));
    exchange.put(Retryable.class, new RetryableImpl());

    // context
    setContexts(m, exchange, invocationContext, proxy);

    // setup conduit selector
    prepareConduitSelector(m, currentURI, proxy);

    return m;
  }
Exemple #27
0
 @Override
 protected void writeURI(org.openrdf.model.URI uri) throws IOException {
   URI create = URI.create(uri.toString());
   URI rel = baseURI.relativize(create);
   if (!rel.isAbsolute()) {
     writer.write("<");
     writer.write(TurtleUtil.encodeURIString(rel.toString()));
     writer.write(">");
   } else {
     super.writeURI(uri);
   }
 }
 private String getKBServerUrl(final String uri) throws KillBillClientException {
   try {
     final URI u = new URI(uri);
     if (u.isAbsolute()) {
       return uri;
     } else {
       return String.format("%s%s", kbServerUrl, uri);
     }
   } catch (URISyntaxException e) {
     throw new KillBillClientException(e);
   }
 }
  /**
   * creates a canonical representation of the uriString. This method performs certain translations
   * depending on the type of URI generated by the string.
   */
  private URI canonicalize(String uriString) throws URISyntaxException {
    if ((uriString == null) || (uriString.compareTo("localhost") == 0)) {
      uriString = "//localhost";
      return new URI(uriString);
    }

    URI u = new URI(uriString);

    if (u.isAbsolute()) {
      if (u.isOpaque()) {
        /*
         * this code is here to deal with a special case. For ease of use, we'd like to be able to handle the case where the user specifies hostname:port, not requiring the scheme part. This introduces some subtleties. hostname:port - scheme = hostname - schemespecificpart = port - hostname = null - userinfo=null however, someone could also enter scheme:hostname:port and get into this code. the strategy is to consider this syntax illegal and provide some code to defend against it.
         * Basically, we test that the string contains only one ":" and that the ssp is numeric. If we get two colons, we will attempt to insert the "//" after the first colon and then try to create a URI from the resulting string.
         */
        String scheme = u.getScheme();
        String ssp = u.getSchemeSpecificPart();
        String frag = u.getFragment();
        URI u2 = null;

        int c1index = uriString.indexOf(":");
        int c2index = uriString.lastIndexOf(":");
        if (c2index != c1index) {
          /*
           * this is the scheme:hostname:port case. Attempt to transform this to scheme://hostname:port. If a path part is part of the original strings, it will be included in the SchemeSpecificPart. however, the fragment part must be handled separately.
           */
          if (frag == null) {
            u2 = new URI(scheme + "://" + ssp);
          } else {
            u2 = new URI(scheme + "://" + ssp + "#" + frag);
          }
          return u2;
        }
        /*
         * here we have the <string>:<string> case, possibly with optional path and fragment components. we assume that the part following the colon is a number. we don't check this condition here as it will get detected later anyway.
         */
        u2 = new URI("//" + uriString);
        return u2;
      } else {
        return u;
      }
    } else {
      /*
       * This is the case where we were given a hostname followed by a path part, fragment part, or both a path and fragment part. The key here is that no scheme part was specified. For this case, if the scheme specific part does not begin with "//", then we prefix the "//" to the given string and attempt to create a URI from the resulting string.
       */
      String ssp = u.getSchemeSpecificPart();
      if (ssp.startsWith("//")) {
        return u;
      } else {
        return new URI("//" + uriString);
      }
    }
  }
Exemple #30
0
  private Writer createFileWriter(File outBase, File inBase, URI file) throws IOException {
    URI relative = inBase.toURI().relativize(file);
    File outFile;
    if (relative.isAbsolute()) {
      outFile = new File(outBase, new File(relative).getName());
    } else {
      outFile = new File(outBase, relative.getPath());
    }

    outFile.getParentFile().mkdirs();
    FileOutputStream out = new FileOutputStream(outFile);
    return createUnicodeEscapeWriter(out);
  }