java类java.io.FilterReader的实例源码

public void add(final Class<? extends FilterReader> filterType, final Map<String, ?> properties) {
    transformers.add(new Transformer<Reader, Reader>() {
        public Reader transform(Reader original) {
            try {
                Constructor<? extends FilterReader> constructor = filterType.getConstructor(Reader.class);
                FilterReader result = constructor.newInstance(original);

                if (properties != null) {
                    ConfigureUtil.configureByMap(properties, result);
                }
                return result;
            } catch (Throwable th) {
                throw new InvalidUserDataException("Error - Invalid filter specification for " + filterType.getName(), th);
            }
        }
    });
}

/**
 * Returns a reader wrapping the given reader that only reads half of the maximum number of
 * characters that it could read in read(char[], int, int).
 */
private static Reader newNonBufferFillingReader(Reader reader) {
  return new FilterReader(reader) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      // if a buffer isn't being cleared correctly, this method will eventually start being called
      // with a len of 0 forever
      if (len <= 0) {
        fail("read called with a len of " + len);
      }
      // read fewer than the max number of chars to read
      // shouldn't be a problem unless the buffer is shrinking each call
      return in.read(cbuf, off, Math.max(len - 1024, 0));
    }
  };
}

public void testOnlyOneOpen() throws Exception {
  String testString = "abcdefgh";
  final CharSource source = newCharSource(testString);
  final int[] counter = new int[1];
  CharSource reader = new CharSource() {
    @Override
    public Reader openStream() throws IOException {
      if (counter[0]++ != 0) {
        throw new IllegalStateException("More than one source open");
      }
      return new FilterReader(source.openStream()) {
        @Override public void close() throws IOException {
          super.close();
          counter[0]--;
        }
      };
    }
  };
  Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
  String result = CharStreams.toString(joinedReader);
  assertEquals(testString.length() * 3, result.length());
}

/**
 * Returns a reader wrapping the given reader that only reads half of the maximum number of
 * characters that it could read in read(char[], int, int).
 */
private static Reader newNonBufferFillingReader(Reader reader) {
  return new FilterReader(reader) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      // if a buffer isn't being cleared correctly, this method will eventually start being called
      // with a len of 0 forever
      if (len <= 0) {
        fail("read called with a len of " + len);
      }
      // read fewer than the max number of chars to read
      // shouldn't be a problem unless the buffer is shrinking each call
      return in.read(cbuf, off, Math.max(len - 1024, 0));
    }
  };
}

public void testOnlyOneOpen() throws Exception {
  String testString = "abcdefgh";
  final CharSource source = newCharSource(testString);
  final int[] counter = new int[1];
  CharSource reader = new CharSource() {
    @Override
    public Reader openStream() throws IOException {
      if (counter[0]++ != 0) {
        throw new IllegalStateException("More than one source open");
      }
      return new FilterReader(source.openStream()) {
        @Override public void close() throws IOException {
          super.close();
          counter[0]--;
        }
      };
    }
  };
  Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
  String result = CharStreams.toString(joinedReader);
  assertEquals(testString.length() * 3, result.length());
}

/**
 * Returns a reader wrapping the given reader that only reads half of the maximum number of
 * characters that it could read in read(char[], int, int).
 */
private static Reader newNonBufferFillingReader(Reader reader) {
  return new FilterReader(reader) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      // if a buffer isn't being cleared correctly, this method will eventually start being called
      // with a len of 0 forever
      if (len <= 0) {
        fail("read called with a len of " + len);
      }
      // read fewer than the max number of chars to read
      // shouldn't be a problem unless the buffer is shrinking each call
      return in.read(cbuf, off, Math.max(len - 1024, 0));
    }
  };
}

public void testOnlyOneOpen() throws Exception {
  String testString = "abcdefgh";
  final CharSource source = newCharSource(testString);
  final int[] counter = new int[1];
  CharSource reader = new CharSource() {
    @Override
    public Reader openStream() throws IOException {
      if (counter[0]++ != 0) {
        throw new IllegalStateException("More than one source open");
      }
      return new FilterReader(source.openStream()) {
        @Override public void close() throws IOException {
          super.close();
          counter[0]--;
        }
      };
    }
  };
  Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
  String result = CharStreams.toString(joinedReader);
  assertEquals(testString.length() * 3, result.length());
}

/**
 * @tests java.io.FilterReader#FilterReader(java.io.Reader)
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "Verifies constructor FilterReader(java.io.Reader).",
    method = "FilterReader",
    args = {java.io.Reader.class}
)
public void test_ConstructorLjava_io_Reader() {

    FilterReader myReader = null;

    called = true;

    try {
        myReader = new MyFilterReader(null);
        fail("NullPointerException expected.");
    } catch (NullPointerException e) {
        // expected
    }
}

/**
 * Returns a reader wrapping the given reader that only reads half of the maximum number of
 * characters that it could read in read(char[], int, int).
 */
private static Reader newNonBufferFillingReader(Reader reader) {
  return new FilterReader(reader) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      // if a buffer isn't being cleared correctly, this method will eventually start being called
      // with a len of 0 forever
      if (len <= 0) {
        fail("read called with a len of " + len);
      }
      // read fewer than the max number of chars to read
      // shouldn't be a problem unless the buffer is shrinking each call
      return in.read(cbuf, off, Math.max(len - 1024, 0));
    }
  };
}

public void testOnlyOneOpen() throws Exception {
  String testString = "abcdefgh";
  final CharSource source = newCharSource(testString);
  final int[] counter = new int[1];
  CharSource reader =
      new CharSource() {
        @Override
        public Reader openStream() throws IOException {
          if (counter[0]++ != 0) {
            throw new IllegalStateException("More than one source open");
          }
          return new FilterReader(source.openStream()) {
            @Override
            public void close() throws IOException {
              super.close();
              counter[0]--;
            }
          };
        }
      };
  Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
  String result = CharStreams.toString(joinedReader);
  assertEquals(testString.length() * 3, result.length());
}

/**
 * Returns a reader wrapping the given reader that only reads half of the maximum number of
 * characters that it could read in read(char[], int, int).
 */
private static Reader newNonBufferFillingReader(Reader reader) {
  return new FilterReader(reader) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      // if a buffer isn't being cleared correctly, this method will eventually start being called
      // with a len of 0 forever
      if (len <= 0) {
        fail("read called with a len of " + len);
      }
      // read fewer than the max number of chars to read
      // shouldn't be a problem unless the buffer is shrinking each call
      return in.read(cbuf, off, Math.max(len - 1024, 0));
    }
  };
}

public void testOnlyOneOpen() throws Exception {
  String testString = "abcdefgh";
  final CharSource source = newCharSource(testString);
  final int[] counter = new int[1];
  CharSource reader =
      new CharSource() {
        @Override
        public Reader openStream() throws IOException {
          if (counter[0]++ != 0) {
            throw new IllegalStateException("More than one source open");
          }
          return new FilterReader(source.openStream()) {
            @Override
            public void close() throws IOException {
              super.close();
              counter[0]--;
            }
          };
        }
      };
  Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
  String result = CharStreams.toString(joinedReader);
  assertEquals(testString.length() * 3, result.length());
}

/**
 * @see #getReader
 */
public Reader getInternalReader(long characterPosition)
        throws IOException, SQLException {
    if (this.internalReader == null) {
        // getCSD obtains a descriptor for the stream to allow the reader
        // to configure itself.
        this.internalReader = new UTF8Reader(getCSD(), conChild,
                conChild.getConnectionSynchronization());
        this.unclosableInternalReader =
                new FilterReader(this.internalReader) {
                    public void close() {
                        // Do nothing.
                        // Stream will be closed when the Clob is released.
                    }
                };
    }
    try {
        this.internalReader.reposition(characterPosition);
    } catch (StandardException se) {
        throw Util.generateCsSQLException(se);
    }
    return this.unclosableInternalReader;
}

public CopySpec filter(final Class<? extends FilterReader> filterType) {
    appendCopyAction(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(filterType);
        }
    });
    return this;
}

public CopySpec filter(final Map<String, ?> properties, final Class<? extends FilterReader> filterType) {
    appendCopyAction(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(properties, filterType);
        }
    });
    return this;
}

public InputStream getInputStream() throws IOException {
    if (inputOutput == null) {
        throw new IllegalStateException("not started");
    }
    return new ReaderInputStream(
            new FilterReader(inputOutput.getIn()) {
                @Override
                public void close() throws IOException {
                    // do not close the input, JShell may be reset.
                }
            }, "UTF-8" // NOI18N
    );
}

private static Reader getChunkedReader(String input, final int chunk) {
  return new FilterReader(new StringReader(input)) {
    @Override public int read(char[] cbuf, int off, int len)
        throws IOException {
      return super.read(cbuf, off, Math.min(chunk, len));
    }
  };
}

private static Reader getChunkedReader(String input, final int chunk) {
  return new FilterReader(new StringReader(input)) {
    @Override public int read(char[] cbuf, int off, int len)
        throws IOException {
      return super.read(cbuf, off, Math.min(chunk, len));
    }
  };
}

private Reader doTransform(ResourceRootFilter filter, Reader original) {
  if ("RenamingCopyFilter" .equals(filter.filterType)) {
    final Matcher matcher = (Matcher)filter.getProperties().get("matcher");
    final String replacement = (String)filter.getProperties().get("replacement");
    if (matcher == null || replacement == null) return original;

    matcher.reset(myOutputFileRef.get().getName());
    if (matcher.find()) {
      final String newFileName = matcher.replaceFirst(replacement);
      myOutputFileRef.set(new File(myOutputFileRef.get().getParentFile(), newFileName));
    }
    return original;
  }
  try {
    Class<?> clazz = Class.forName(filter.filterType);
    if (!FilterReader.class.isAssignableFrom(clazz)) {
      myContext.processMessage(
        new CompilerMessage(
          GradleResourcesBuilder.BUILDER_NAME, BuildMessage.Kind.WARNING,
          String.format("Error - Invalid filter specification for %s. It should extend java.io.FilterReader.", filter.filterType), null)
      );
    }
    Constructor constructor = clazz.getConstructor(Reader.class);
    FilterReader result = (FilterReader)constructor.newInstance(original);
    final Map<Object, Object> properties = filter.getProperties();
    if (!properties.isEmpty()) {
      ConfigureUtil.configureByMap(properties, result);
    }
    return result;
  }
  catch (Throwable th) {
    myContext.processMessage(new CompilerMessage(
                               GradleResourcesBuilder.BUILDER_NAME, BuildMessage.Kind.WARNING,
                               String.format("Error - Failed to apply filter(%s): %s", filter.filterType, th.getMessage()), null)
    );
  }
  return original;
}

public void test_ConstructorLjava_io_Reader() {

        FilterReader myReader = null;

        called = true;

        try {
            myReader = new MyFilterReader(null);
            fail("NullPointerException expected.");
        } catch (NullPointerException e) {
            // expected
        }
    }

private static Reader getChunkedReader(String input, final int chunk) {
  return new FilterReader(new StringReader(input)) {
    @Override public int read(char[] cbuf, int off, int len)
        throws IOException {
      return super.read(cbuf, off, Math.min(chunk, len));
    }
  };
}

public CopySpec filter(final Class<? extends FilterReader> filterType) {
    copyActions.add(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(filterType);
        }
    });
    return this;
}

public CopySpec filter(final Map<String, ?> properties, final Class<? extends FilterReader> filterType) {
    copyActions.add(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(properties, filterType);
        }
    });
    return this;
}

public CopySpec filter(final Class<? extends FilterReader> filterType) {
    actions.add(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(filterType);
        }
    });
    return this;
}

public CopySpec filter(final Map<String, ?> properties, final Class<? extends FilterReader> filterType) {
    actions.add(new Action<FileCopyDetails>() {
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(properties, filterType);
        }
    });
    return this;
}

private static Reader getChunkedReader(String input, final int chunk) {
  return new FilterReader(new StringReader(input)) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      return super.read(cbuf, off, Math.min(chunk, len));
    }
  };
}

private static Reader getChunkedReader(String input, final int chunk) {
  return new FilterReader(new StringReader(input)) {
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
      return super.read(cbuf, off, Math.min(chunk, len));
    }
  };
}

public Reader unwrap(FilterReader originalReader) throws IllegalArgumentException {
    try {
        return (Reader) internalField.get(originalReader);
    } catch (Exception ex) {
        throw new IllegalArgumentException("Could not access private \"in\" field of the given FilterReader (actual class: " + originalReader.getClass().getCanonicalName() + ")", ex);
    }
}

private static Reader doNotClose(Reader input) {
    return new FilterReader(input) {
        @Override
        public void close() {
            // NOTHING.
        }
    };
}

/**
 * {@inheritDoc}
 */
public AbstractCopyTask filter(Map<String, ?> properties, Class<? extends FilterReader> filterType) {
    getMainSpec().filter(properties, filterType);
    return this;
}