jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java - jetty - Git at Google

 //
 //  ========================================================================
 //  Copyright (c) 1995-2017 Mort Bay Consulting Pty. Ltd.
 //  ------------------------------------------------------------------------
 //  All rights reserved. This program and the accompanying materials
 //  are made available under the terms of the Eclipse Public License v1.0
 //  and Apache License v2.0 which accompanies this distribution.
 //
 //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //

 package org.eclipse.jetty.util.resource;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.channels.FileChannel;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.file.DirectoryIteratorException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.InvalidPathException;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.FileTime;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.jetty.util.IO;
 import org.eclipse.jetty.util.StringUtil;
 import org.eclipse.jetty.util.URIUtil;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;

 /**
  * Java NIO Path equivalent of FileResource.
  */
 public class PathResource extends Resource
 {
     private static final Logger LOG = Log.getLogger(PathResource.class);
     private final static LinkOption NO_FOLLOW_LINKS[] = new LinkOption[] { LinkOption.NOFOLLOW_LINKS };
     private final static LinkOption FOLLOW_LINKS[] = new LinkOption[] {};

     private final Path path;
     private final Path alias;
     private final URI uri;

     private final Path checkAliasPath()
     {
         Path abs = path;

         /* Catch situation where the Path class has already normalized
          * the URI eg. input path "aa./foo.txt"
          * from an #addPath(String) is normalized away during
          * the creation of a Path object reference.
          * If the URI is different then the Path.toUri() then
          * we will just use the original URI to construct the
          * alias reference Path.
          */

         if(!URIUtil.equalsIgnoreEncodings(uri,path.toUri()))
         {
             try
             {
                 return Paths.get(uri).toRealPath(FOLLOW_LINKS);
             }
             catch (IOException ignored)
             {
                 // If the toRealPath() call fails, then let
                 // the alias checking routines continue on
                 // to other techniques.
                 LOG.ignore(ignored);
             }
         }

         if (!abs.isAbsolute())
         {
             abs = path.toAbsolutePath();
         }

         try
         {
             if (Files.isSymbolicLink(path))
                 return path.getParent().resolve(Files.readSymbolicLink(path));
             if (Files.exists(path))
             {
                 Path real = abs.toRealPath(FOLLOW_LINKS);

                 /*
                  * If the real path is not the same as the absolute path
                  * then we know that the real path is the alias for the
                  * provided path.
                  *
                  * For OS's that are case insensitive, this should
                  * return the real (on-disk / case correct) version
                  * of the path.
                  *
                  * We have to be careful on Windows and OSX.
                  *
                  * Assume we have the following scenario
                  *   Path a = new File("foo").toPath();
                  *   Files.createFile(a);
                  *   Path b = new File("FOO").toPath();
                  *
                  * There now exists a file called "foo" on disk.
                  * Using Windows or OSX, with a Path reference of
                  * "FOO", "Foo", "fOO", etc.. means the following
                  *
                  *                        |  OSX    |  Windows   |  Linux
                  * -----------------------+---------+------------+---------
                  * Files.exists(a)        |  True   |  True      |  True
                  * Files.exists(b)        |  True   |  True      |  False
                  * Files.isSameFile(a,b)  |  True   |  True      |  False
                  * a.equals(b)            |  False  |  True      |  False
                  *
                  * See the javadoc for Path.equals() for details about this FileSystem
                  * behavior difference
                  *
                  * We also cannot rely on a.compareTo(b) as this is roughly equivalent
                  * in implementation to a.equals(b)
                  */

                 int absCount = abs.getNameCount();
                 int realCount = real.getNameCount();
                 if (absCount != realCount)
                 {
                     // different number of segments
                     return real;
                 }

                 // compare each segment of path, backwards
                 for (int i = realCount-1; i >= 0; i--)
                 {
                     if (!abs.getName(i).toString().equals(real.getName(i).toString()))
                     {
                         return real;
                     }
                 }
             }
         }
         catch (IOException e)
         {
             LOG.ignore(e);
         }
         catch (Exception e)
         {
             LOG.warn("bad alias ({} {}) for {}", e.getClass().getName(), e.getMessage(),path);
         }
         return null;
     }

     /**
      * Construct a new PathResource from a File object.
      * <p>
      * An invocation of this convenience constructor of the form.
      * </p>
      * <pre>
      * new PathResource(file);
      * </pre>
      * <p>
      * behaves in exactly the same way as the expression
      * </p>
      * <pre>
      * new PathResource(file.toPath());
      * </pre>

      * @param file the file to use
      */
     public PathResource(File file)
     {
         this(file.toPath());
     }

     /**
      * Construct a new PathResource from a Path object.
      *
      * @param path the path to use
      */
     public PathResource(Path path)
     {
         this.path = path.toAbsolutePath();
         assertValidPath(path);
         this.uri = this.path.toUri();
         this.alias = checkAliasPath();
     }

     /**
      * Construct a new PathResource from a parent PathResource
      * and child sub path
      *
      * @param parent the parent path resource
      * @param childPath the child sub path
      */
     private PathResource(PathResource parent, String childPath) throws MalformedURLException
     {
         // Calculate the URI and the path separately, so that any aliasing done by
         // FileSystem.getPath(path,childPath) is visiable as a difference to the URI
         // obtained via URIUtil.addDecodedPath(uri,childPath)

         this.path = parent.path.getFileSystem().getPath(parent.path.toString(), childPath);
         if (isDirectory() &&!childPath.endsWith("/"))
             childPath+="/";
         this.uri = URIUtil.addPath(parent.uri,childPath);
         this.alias = checkAliasPath();
     }

     /**
      * Construct a new PathResource from a URI object.
      * <p>
      * Must be an absolute URI using the <code>file</code> scheme.
      *
      * @param uri the URI to build this PathResource from.
      * @throws IOException if unable to construct the PathResource from the URI.
      */
     public PathResource(URI uri) throws IOException
     {
         if (!uri.isAbsolute())
         {
             throw new IllegalArgumentException("not an absolute uri");
         }

         if (!uri.getScheme().equalsIgnoreCase("file"))
         {
             throw new IllegalArgumentException("not file: scheme");
         }

         Path path;
         try
         {
             path = Paths.get(uri);
         }
         catch (InvalidPathException e)
         {
             throw e;
         }
         catch (IllegalArgumentException e)
         {
             throw e;
         }
         catch (Exception e)
         {
             LOG.ignore(e);
             throw new IOException("Unable to build Path from: " + uri,e);
         }

         this.path = path.toAbsolutePath();
         this.uri = path.toUri();
         this.alias = checkAliasPath();
     }

     /**
      * Create a new PathResource from a provided URL object.
      * <p>
      * An invocation of this convenience constructor of the form.
      * </p>
      * <pre>
      * new PathResource(url);
      * </pre>
      * <p>
      * behaves in exactly the same way as the expression
      * </p>
      * <pre>
      * new PathResource(url.toURI());
      * </pre>
      *
      * @param url the url to attempt to create PathResource from
      * @throws IOException if URL doesn't point to a location that can be transformed to a PathResource
      * @throws URISyntaxException if the provided URL was malformed
      */
     public PathResource(URL url) throws IOException, URISyntaxException
     {
         this(url.toURI());
     }

     @Override
     public Resource addPath(final String subpath) throws IOException, MalformedURLException
     {
         String cpath = URIUtil.canonicalPath(subpath);

         if ((cpath == null) || (cpath.length() == 0))
             throw new MalformedURLException(subpath);

         if ("/".equals(cpath))
             return this;

         // subpaths are always under PathResource
         // compensate for input subpaths like "/subdir"
         // where default resolve behavior would be
         // to treat that like an absolute path

         return new PathResource(this, subpath);
     }

     private void assertValidPath(Path path)
     {
         // TODO merged from 9.2, check if necessary
         String str = path.toString();
         int idx = StringUtil.indexOfControlChars(str);
         if(idx >= 0)
         {
             throw new InvalidPathException(str, "Invalid Character at index " + idx);
         }
     }

     @Override
     public void close()
     {
         // not applicable for FileSytem / Path
     }

     @Override
     public boolean delete() throws SecurityException
     {
         try
         {
             return Files.deleteIfExists(path);
         }
         catch (IOException e)
         {
             LOG.ignore(e);
             return false;
         }
     }

     @Override
     public boolean equals(Object obj)
     {
         if (this == obj)
         {
             return true;
         }
         if (obj == null)
         {
             return false;
         }
         if (getClass() != obj.getClass())
         {
             return false;
         }
         PathResource other = (PathResource)obj;
         if (path == null)
         {
             if (other.path != null)
             {
                 return false;
             }
         }
         else if (!path.equals(other.path))
         {
             return false;
         }
         return true;
     }

     @Override
     public boolean exists()
     {
         return Files.exists(path,NO_FOLLOW_LINKS);
     }

     @Override
     public File getFile() throws IOException
     {
         return path.toFile();
     }

     /**
      * @return the {@link Path} of the resource
      */
     public Path getPath()
     {
         return path;
     }

     @Override
     public InputStream getInputStream() throws IOException
     {
         /* Mimic behavior from old FileResource class and its
          * usage of java.io.FileInputStream(File) which will trigger
          * an IOException on construction if the path is a directory
          */
         if (Files.isDirectory(path))
             throw new IOException(path + " is a directory");

         return Files.newInputStream(path,StandardOpenOption.READ);
     }

     @Override
     public String getName()
     {
         return path.toAbsolutePath().toString();
     }

     @Override
     public ReadableByteChannel getReadableByteChannel() throws IOException
     {
         return FileChannel.open(path,StandardOpenOption.READ);
     }

     @Override
     public URI getURI()
     {
         return this.uri;
     }

     @Override
     public URL getURL()
     {
         try
         {
             return path.toUri().toURL();
         }
         catch (MalformedURLException e)
         {
             return null;
         }
     }

     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result = (prime * result) + ((path == null)?0:path.hashCode());
         return result;
     }

     @Override
     public boolean isContainedIn(Resource r) throws MalformedURLException
     {
         // not applicable for FileSystem / path
         return false;
     }

     @Override
     public boolean isDirectory()
     {
         return Files.isDirectory(path,FOLLOW_LINKS);
     }

     @Override
     public long lastModified()
     {
         try
         {
             FileTime ft = Files.getLastModifiedTime(path,FOLLOW_LINKS);
             return ft.toMillis();
         }
         catch (IOException e)
         {
             LOG.ignore(e);
             return 0;
         }
     }

     @Override
     public long length()
     {
         try
         {
             return Files.size(path);
         }
         catch (IOException e)
         {
             // in case of error, use File.length logic of 0L
             return 0L;
         }
     }

     @Override
     public boolean isAlias()
     {
         return this.alias!=null;
     }

     /**
      * The Alias as a Path.
      * <p>
      *     Note: this cannot return the alias as a DIFFERENT path in 100% of situations,
      *     due to Java's internal Path/File normalization.
      * </p>
      *
      * @return the alias as a path.
      */
     public Path getAliasPath()
     {
         return this.alias;
     }

     @Override
     public URI getAlias()
     {
         return this.alias==null?null:this.alias.toUri();
     }

     @Override
     public String[] list()
     {
         try (DirectoryStream<Path> dir = Files.newDirectoryStream(path))
         {
             List<String> entries = new ArrayList<>();
             for (Path entry : dir)
             {
                 String name = entry.getFileName().toString();

                 if (Files.isDirectory(entry))
                 {
                     name += "/";
                 }

                 entries.add(name);
             }
             int size = entries.size();
             return entries.toArray(new String[size]);
         }
         catch (DirectoryIteratorException e)
         {
             LOG.debug(e);
         }
         catch (IOException e)
         {
             LOG.debug(e);
         }
         return null;
     }

     @Override
     public boolean renameTo(Resource dest) throws SecurityException
     {
         if (dest instanceof PathResource)
         {
             PathResource destRes = (PathResource)dest;
             try
             {
                 Path result = Files.move(path,destRes.path);
                 return Files.exists(result,NO_FOLLOW_LINKS);
             }
             catch (IOException e)
             {
                 LOG.ignore(e);
                 return false;
             }
         }
         else
         {
             return false;
         }
     }

     @Override
     public void copyTo(File destination) throws IOException
     {
         if (isDirectory())
         {
             IO.copyDir(this.path.toFile(),destination);
         }
         else
         {
             Files.copy(this.path,destination.toPath());
         }
     }

     @Override
     public String toString()
     {
         return this.uri.toASCIIString();
     }
 }
	//
	// ========================================================================
	// Copyright (c) 1995-2017 Mort Bay Consulting Pty. Ltd.
	// ------------------------------------------------------------------------
	// All rights reserved. This program and the accompanying materials
	// are made available under the terms of the Eclipse Public License v1.0
	// and Apache License v2.0 which accompanies this distribution.
	//
	// The Eclipse Public License is available at
	// http://www.eclipse.org/legal/epl-v10.html
	//
	// The Apache License v2.0 is available at
	// http://www.opensource.org/licenses/apache2.0.php
	//
	// You may elect to redistribute this code under either of these licenses.
	// ========================================================================
	//

	package org.eclipse.jetty.util.resource;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.MalformedURLException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.net.URL;
	import java.nio.channels.FileChannel;
	import java.nio.channels.ReadableByteChannel;
	import java.nio.file.DirectoryIteratorException;
	import java.nio.file.DirectoryStream;
	import java.nio.file.Files;
	import java.nio.file.InvalidPathException;
	import java.nio.file.LinkOption;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.StandardOpenOption;
	import java.nio.file.attribute.FileTime;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.jetty.util.IO;
	import org.eclipse.jetty.util.StringUtil;
	import org.eclipse.jetty.util.URIUtil;
	import org.eclipse.jetty.util.log.Log;
	import org.eclipse.jetty.util.log.Logger;

	/**
	* Java NIO Path equivalent of FileResource.
	*/
	public class PathResource extends Resource
	{
	private static final Logger LOG = Log.getLogger(PathResource.class);
	private final static LinkOption NO_FOLLOW_LINKS[] = new LinkOption[] { LinkOption.NOFOLLOW_LINKS };
	private final static LinkOption FOLLOW_LINKS[] = new LinkOption[] {};

	private final Path path;
	private final Path alias;
	private final URI uri;

	private final Path checkAliasPath()
	{
	Path abs = path;

	/* Catch situation where the Path class has already normalized
	* the URI eg. input path "aa./foo.txt"
	* from an #addPath(String) is normalized away during
	* the creation of a Path object reference.
	* If the URI is different then the Path.toUri() then
	* we will just use the original URI to construct the
	* alias reference Path.
	*/

	if(!URIUtil.equalsIgnoreEncodings(uri,path.toUri()))
	{
	try
	{
	return Paths.get(uri).toRealPath(FOLLOW_LINKS);
	}
	catch (IOException ignored)
	{
	// If the toRealPath() call fails, then let
	// the alias checking routines continue on
	// to other techniques.
	LOG.ignore(ignored);
	}
	}

	if (!abs.isAbsolute())
	{
	abs = path.toAbsolutePath();
	}

	try
	{
	if (Files.isSymbolicLink(path))
	return path.getParent().resolve(Files.readSymbolicLink(path));
	if (Files.exists(path))
	{
	Path real = abs.toRealPath(FOLLOW_LINKS);

	/*
	* If the real path is not the same as the absolute path
	* then we know that the real path is the alias for the
	* provided path.
	*
	* For OS's that are case insensitive, this should
	* return the real (on-disk / case correct) version
	* of the path.
	*
	* We have to be careful on Windows and OSX.
	*
	* Assume we have the following scenario
	* Path a = new File("foo").toPath();
	* Files.createFile(a);
	* Path b = new File("FOO").toPath();
	*
	* There now exists a file called "foo" on disk.
	* Using Windows or OSX, with a Path reference of
	* "FOO", "Foo", "fOO", etc.. means the following
	*
	* \| OSX \| Windows \| Linux
	* -----------------------+---------+------------+---------
	* Files.exists(a) \| True \| True \| True
	* Files.exists(b) \| True \| True \| False
	* Files.isSameFile(a,b) \| True \| True \| False
	* a.equals(b) \| False \| True \| False
	*
	* See the javadoc for Path.equals() for details about this FileSystem
	* behavior difference
	*
	* We also cannot rely on a.compareTo(b) as this is roughly equivalent
	* in implementation to a.equals(b)
	*/

	int absCount = abs.getNameCount();
	int realCount = real.getNameCount();
	if (absCount != realCount)
	{
	// different number of segments
	return real;
	}

	// compare each segment of path, backwards
	for (int i = realCount-1; i >= 0; i--)
	{
	if (!abs.getName(i).toString().equals(real.getName(i).toString()))
	{
	return real;
	}
	}
	}
	}
	catch (IOException e)
	{
	LOG.ignore(e);
	}
	catch (Exception e)
	{
	LOG.warn("bad alias ({} {}) for {}", e.getClass().getName(), e.getMessage(),path);
	}
	return null;
	}

	/**
	* Construct a new PathResource from a File object.
	* <p>
	* An invocation of this convenience constructor of the form.
	* </p>
	* <pre>
	* new PathResource(file);
	* </pre>
	* <p>
	* behaves in exactly the same way as the expression
	* </p>
	* <pre>
	* new PathResource(file.toPath());
	* </pre>

	* @param file the file to use
	*/
	public PathResource(File file)
	{
	this(file.toPath());
	}

	/**
	* Construct a new PathResource from a Path object.
	*
	* @param path the path to use
	*/
	public PathResource(Path path)
	{
	this.path = path.toAbsolutePath();
	assertValidPath(path);
	this.uri = this.path.toUri();
	this.alias = checkAliasPath();
	}

	/**
	* Construct a new PathResource from a parent PathResource
	* and child sub path
	*
	* @param parent the parent path resource
	* @param childPath the child sub path
	*/
	private PathResource(PathResource parent, String childPath) throws MalformedURLException
	{
	// Calculate the URI and the path separately, so that any aliasing done by
	// FileSystem.getPath(path,childPath) is visiable as a difference to the URI
	// obtained via URIUtil.addDecodedPath(uri,childPath)

	this.path = parent.path.getFileSystem().getPath(parent.path.toString(), childPath);
	if (isDirectory() &&!childPath.endsWith("/"))
	childPath+="/";
	this.uri = URIUtil.addPath(parent.uri,childPath);
	this.alias = checkAliasPath();
	}

	/**
	* Construct a new PathResource from a URI object.
	* <p>
	* Must be an absolute URI using the <code>file</code> scheme.
	*
	* @param uri the URI to build this PathResource from.
	* @throws IOException if unable to construct the PathResource from the URI.
	*/
	public PathResource(URI uri) throws IOException
	{
	if (!uri.isAbsolute())
	{
	throw new IllegalArgumentException("not an absolute uri");
	}

	if (!uri.getScheme().equalsIgnoreCase("file"))
	{
	throw new IllegalArgumentException("not file: scheme");
	}

	Path path;
	try
	{
	path = Paths.get(uri);
	}
	catch (InvalidPathException e)
	{
	throw e;
	}
	catch (IllegalArgumentException e)
	{
	throw e;
	}
	catch (Exception e)
	{
	LOG.ignore(e);
	throw new IOException("Unable to build Path from: " + uri,e);
	}

	this.path = path.toAbsolutePath();
	this.uri = path.toUri();
	this.alias = checkAliasPath();
	}

	/**
	* Create a new PathResource from a provided URL object.
	* <p>
	* An invocation of this convenience constructor of the form.
	* </p>
	* <pre>
	* new PathResource(url);
	* </pre>
	* <p>
	* behaves in exactly the same way as the expression
	* </p>
	* <pre>
	* new PathResource(url.toURI());
	* </pre>
	*
	* @param url the url to attempt to create PathResource from
	* @throws IOException if URL doesn't point to a location that can be transformed to a PathResource
	* @throws URISyntaxException if the provided URL was malformed
	*/
	public PathResource(URL url) throws IOException, URISyntaxException
	{
	this(url.toURI());
	}

	@Override
	public Resource addPath(final String subpath) throws IOException, MalformedURLException
	{
	String cpath = URIUtil.canonicalPath(subpath);

	if ((cpath == null) \|\| (cpath.length() == 0))
	throw new MalformedURLException(subpath);

	if ("/".equals(cpath))
	return this;

	// subpaths are always under PathResource
	// compensate for input subpaths like "/subdir"
	// where default resolve behavior would be
	// to treat that like an absolute path

	return new PathResource(this, subpath);
	}

	private void assertValidPath(Path path)
	{
	// TODO merged from 9.2, check if necessary
	String str = path.toString();
	int idx = StringUtil.indexOfControlChars(str);
	if(idx >= 0)
	{
	throw new InvalidPathException(str, "Invalid Character at index " + idx);
	}
	}

	@Override
	public void close()
	{
	// not applicable for FileSytem / Path
	}

	@Override
	public boolean delete() throws SecurityException
	{
	try
	{
	return Files.deleteIfExists(path);
	}
	catch (IOException e)
	{
	LOG.ignore(e);
	return false;
	}
	}

	@Override
	public boolean equals(Object obj)
	{
	if (this == obj)
	{
	return true;
	}
	if (obj == null)
	{
	return false;
	}
	if (getClass() != obj.getClass())
	{
	return false;
	}
	PathResource other = (PathResource)obj;
	if (path == null)
	{
	if (other.path != null)
	{
	return false;
	}
	}
	else if (!path.equals(other.path))
	{
	return false;
	}
	return true;
	}

	@Override
	public boolean exists()
	{
	return Files.exists(path,NO_FOLLOW_LINKS);
	}

	@Override
	public File getFile() throws IOException
	{
	return path.toFile();
	}

	/**
	* @return the {@link Path} of the resource
	*/
	public Path getPath()
	{
	return path;
	}

	@Override
	public InputStream getInputStream() throws IOException
	{
	/* Mimic behavior from old FileResource class and its
	* usage of java.io.FileInputStream(File) which will trigger
	* an IOException on construction if the path is a directory
	*/
	if (Files.isDirectory(path))
	throw new IOException(path + " is a directory");

	return Files.newInputStream(path,StandardOpenOption.READ);
	}

	@Override
	public String getName()
	{
	return path.toAbsolutePath().toString();
	}

	@Override
	public ReadableByteChannel getReadableByteChannel() throws IOException
	{
	return FileChannel.open(path,StandardOpenOption.READ);
	}

	@Override
	public URI getURI()
	{
	return this.uri;
	}

	@Override
	public URL getURL()
	{
	try
	{
	return path.toUri().toURL();
	}
	catch (MalformedURLException e)
	{
	return null;
	}
	}

	@Override
	public int hashCode()
	{
	final int prime = 31;
	int result = 1;
	result = (prime * result) + ((path == null)?0:path.hashCode());
	return result;
	}

	@Override
	public boolean isContainedIn(Resource r) throws MalformedURLException
	{
	// not applicable for FileSystem / path
	return false;
	}

	@Override
	public boolean isDirectory()
	{
	return Files.isDirectory(path,FOLLOW_LINKS);
	}

	@Override
	public long lastModified()
	{
	try
	{
	FileTime ft = Files.getLastModifiedTime(path,FOLLOW_LINKS);
	return ft.toMillis();
	}
	catch (IOException e)
	{
	LOG.ignore(e);
	return 0;
	}
	}

	@Override
	public long length()
	{
	try
	{
	return Files.size(path);
	}
	catch (IOException e)
	{
	// in case of error, use File.length logic of 0L
	return 0L;
	}
	}

	@Override
	public boolean isAlias()
	{
	return this.alias!=null;
	}

	/**
	* The Alias as a Path.
	* <p>
	* Note: this cannot return the alias as a DIFFERENT path in 100% of situations,
	* due to Java's internal Path/File normalization.
	* </p>
	*
	* @return the alias as a path.
	*/
	public Path getAliasPath()
	{
	return this.alias;
	}

	@Override
	public URI getAlias()
	{
	return this.alias==null?null:this.alias.toUri();
	}

	@Override
	public String[] list()
	{
	try (DirectoryStream<Path> dir = Files.newDirectoryStream(path))
	{
	List<String> entries = new ArrayList<>();
	for (Path entry : dir)
	{
	String name = entry.getFileName().toString();

	if (Files.isDirectory(entry))
	{
	name += "/";
	}

	entries.add(name);
	}
	int size = entries.size();
	return entries.toArray(new String[size]);
	}
	catch (DirectoryIteratorException e)
	{
	LOG.debug(e);
	}
	catch (IOException e)
	{
	LOG.debug(e);
	}
	return null;
	}

	@Override
	public boolean renameTo(Resource dest) throws SecurityException
	{
	if (dest instanceof PathResource)
	{
	PathResource destRes = (PathResource)dest;
	try
	{
	Path result = Files.move(path,destRes.path);
	return Files.exists(result,NO_FOLLOW_LINKS);
	}
	catch (IOException e)
	{
	LOG.ignore(e);
	return false;
	}
	}
	else
	{
	return false;
	}
	}

	@Override
	public void copyTo(File destination) throws IOException
	{
	if (isDirectory())
	{
	IO.copyDir(this.path.toFile(),destination);
	}
	else
	{
	Files.copy(this.path,destination.toPath());
	}
	}

	@Override
	public String toString()
	{
	return this.uri.toASCIIString();
	}
	}