lucene/test-framework/src/java/org/apache/lucene/mockfile/FilterPath.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.lucene.mockfile;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.ProviderMismatchException;
import java.nio.file.WatchEvent.Kind;
import java.nio.file.WatchEvent.Modifier;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Iterator;

import org.apache.lucene.util.SuppressForbidden;

/**  
 * A {@code FilterPath} contains another 
 * {@code Path}, which it uses as its basic 
 * source of data, possibly transforming the data along the 
 * way or providing additional functionality. 
 */
public class FilterPath implements Path {
  
  /** 
   * The underlying {@code Path} instance. 
   */
  protected final Path delegate;
  
  /** 
   * The parent {@code FileSystem} for this path. 
   */
  protected final FileSystem fileSystem;
  
  /**
   * Construct a {@code FilterPath} with parent
   * {@code fileSystem}, based on the specified base path.
   * @param delegate specified base path.
   * @param fileSystem parent fileSystem.
   */
  public FilterPath(Path delegate, FileSystem fileSystem) {
    this.delegate = delegate;
    this.fileSystem = fileSystem;
  }
  
  /** 
   * Get the underlying wrapped path.
   * @return wrapped path.
   */
  public Path getDelegate() {
    return delegate;
  }

  @Override
  public FileSystem getFileSystem() {
    return fileSystem;
  }

  @Override
  public boolean isAbsolute() {
    return delegate.isAbsolute();
  }

  @Override
  public Path getRoot() {
    Path root = delegate.getRoot();
    if (root == null) {
      return null;
    }
    return wrap(root);
  }

  @Override
  public Path getFileName() {
    Path fileName = delegate.getFileName();
    if (fileName == null) {
      return null;
    }
    return wrap(fileName);
  }

  @Override
  public Path getParent() {
    Path parent = delegate.getParent();
    if (parent == null) {
      return null;
    }
    return wrap(parent);
  }

  @Override
  public int getNameCount() {
    return delegate.getNameCount();
  }

  @Override
  public Path getName(int index) {
    return wrap(delegate.getName(index));
  }

  @Override
  public Path subpath(int beginIndex, int endIndex) {
    return wrap(delegate.subpath(beginIndex, endIndex));
  }

  @Override
  public boolean startsWith(Path other) {
    return delegate.startsWith(toDelegate(other));
  }

  @Override
  public boolean startsWith(String other) {
    return delegate.startsWith(other);
  }

  @Override
  public boolean endsWith(Path other) {
    return delegate.endsWith(toDelegate(other));
  }

  @Override
  public boolean endsWith(String other) {
    return delegate.startsWith(other);
  }

  @Override
  public Path normalize() {
    return wrap(delegate.normalize());
  }

  @Override
  public Path resolve(Path other) {
    return wrap(delegate.resolve(toDelegate(other)));
  }

  @Override
  public Path resolve(String other) {
    return wrap(delegate.resolve(other));
  }

  @Override
  public Path resolveSibling(Path other) {
    return wrap(delegate.resolveSibling(toDelegate(other)));
  }

  @Override
  public Path resolveSibling(String other) {
    return wrap(delegate.resolveSibling(other));
  }

  @Override
  public Path relativize(Path other) {
    return wrap(delegate.relativize(toDelegate(other)));
  }

  // TODO: should these methods not expose delegate result directly?
  // it could allow code to "escape" the sandbox... 

  @Override
  public URI toUri() {
    return delegate.toUri();
  }
  
  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public Path toAbsolutePath() {
    return wrap(delegate.toAbsolutePath());
  }

  @Override
  public Path toRealPath(LinkOption... options) throws IOException {
    return wrap(delegate.toRealPath(options));
  }

  @Override
  @SuppressForbidden(reason = "Abstract API requires to use java.io.File")
  public File toFile() {
    // TODO: should we throw exception here?
    return delegate.toFile();
  }

  @Override
  public WatchKey register(WatchService watcher, Kind<?>[] events, Modifier... modifiers) throws IOException {
    return delegate.register(watcher, events, modifiers);
  }

  @Override
  public WatchKey register(WatchService watcher, Kind<?>... events) throws IOException {
    return delegate.register(watcher, events);
  }

  @Override
  public Iterator<Path> iterator() {
    final Iterator<Path> iterator = delegate.iterator();
    return new Iterator<Path>() {
      @Override
      public boolean hasNext() {
        return iterator.hasNext();
      }

      @Override
      public Path next() {
        return wrap(iterator.next());
      }

      @Override
      public void remove() {
        iterator.remove();
      }
    };
  }

  @Override
  public int compareTo(Path other) {
    return delegate.compareTo(toDelegate(other));
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

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

  /**
   * Unwraps all {@code FilterPath}s, returning
   * the innermost {@code Path}.
   * <p>
   * WARNING: this is exposed for testing only!
   * @param path specified path.
   * @return innermost Path instance
   */
  public static Path unwrap(Path path) {
    while (path instanceof FilterPath) {
      path = ((FilterPath)path).delegate;
    }
    return path;
  }
  
  /** Override this to customize the return wrapped
   *  path from various operations */
  protected Path wrap(Path other) {
    return new FilterPath(other, fileSystem);
  }
  
  /** Override this to customize the unboxing of Path
   *  from various operations
   */
  protected Path toDelegate(Path path) {
    if (path instanceof FilterPath) {
      FilterPath fp = (FilterPath) path;
      if (fp.fileSystem != fileSystem) {
        throw new ProviderMismatchException("mismatch, expected: " + fileSystem.provider().getClass() + ", got: " + fp.fileSystem.provider().getClass());
      }
      return fp.delegate;
    } else {
      throw new ProviderMismatchException("mismatch, expected: FilterPath, got: " + path.getClass());
    }
  }
}