DiskLruCache: update from upstream (5160a2b7) · Commits · e / os / android_packages_apps_Eleven

src/org/lineageos/eleven/cache/DiskLruCache.java

deleted100644 → 0

+0 −969

File deleted.

Preview size limit exceeded, changes collapsed.

src/org/lineageos/eleven/cache/ImageCache.java

+1 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ import android.os.Looper;
		import android.os.ParcelFileDescriptor;
		import android.util.Log;

		import org.lineageos.eleven.cache.disklrucache.DiskLruCache;
		import org.lineageos.eleven.utils.ElevenUtils;

		import java.io.File;

src/org/lineageos/eleven/cache/disklrucache/DiskLruCache.java

0 → 100644

+943 −0

File added.

Preview size limit exceeded, changes collapsed.

src/org/lineageos/eleven/cache/disklrucache/StrictLineReader.java

0 → 100644

+196 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 The Android Open Source Project
		*
		* Licensed 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.lineageos.eleven.cache.disklrucache;

		import java.io.ByteArrayOutputStream;
		import java.io.Closeable;
		import java.io.EOFException;
		import java.io.IOException;
		import java.io.InputStream;
		import java.io.UnsupportedEncodingException;
		import java.nio.charset.Charset;

		/**
		* Buffers input from an {@link InputStream} for reading lines.
		*
		* <p>This class is used for buffered reading of lines. For purposes of this class, a line ends
		* with "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated
		* line at end of input is invalid and will be ignored, the caller may use {@code
		* hasUnterminatedLine()} to detect it after catching the {@code EOFException}.
		*
		* <p>This class is intended for reading input that strictly consists of lines, such as line-based
		* cache entries or cache journal. Unlike the {@link java.io.BufferedReader} which in conjunction
		* with {@link java.io.InputStreamReader} provides similar functionality, this class uses different
		* end-of-input reporting and a more restrictive definition of a line.
		*
		* <p>This class supports only charsets that encode '\r' and '\n' as a single byte with value 13
		* and 10, respectively, and the representation of no other character contains these values.
		* We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1.
		* The default charset is US_ASCII.
		*/
		class StrictLineReader implements Closeable {
		private static final byte CR = (byte) '\r';
		private static final byte LF = (byte) '\n';

		private final InputStream in;
		private final Charset charset;

		/*
		* Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
		* and the data in the range [pos, end) is buffered for reading. At end of input, if there is
		* an unterminated line, we set end == -1, otherwise end == pos. If the underlying
		* {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
		*/
		private byte[] buf;
		private int pos;
		private int end;

		/**
		* Constructs a new {@code LineReader} with the specified charset and the default capacity.
		*
		* @param in the {@code InputStream} to read data from.
		* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
		* supported.
		* @throws NullPointerException if {@code in} or {@code charset} is null.
		* @throws IllegalArgumentException if the specified charset is not supported.
		*/
		public StrictLineReader(InputStream in, Charset charset) {
		this(in, 8192, charset);
		}

		/**
		* Constructs a new {@code LineReader} with the specified capacity and charset.
		*
		* @param in the {@code InputStream} to read data from.
		* @param capacity the capacity of the buffer.
		* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
		* supported.
		* @throws NullPointerException if {@code in} or {@code charset} is null.
		* @throws IllegalArgumentException if {@code capacity} is negative or zero
		* or the specified charset is not supported.
		*/
		public StrictLineReader(InputStream in, int capacity, Charset charset) {
		if (in == null \|\| charset == null) {
		throw new NullPointerException();
		}
		if (capacity < 0) {
		throw new IllegalArgumentException("capacity <= 0");
		}
		if (!(charset.equals(Util.US_ASCII))) {
		throw new IllegalArgumentException("Unsupported encoding");
		}

		this.in = in;
		this.charset = charset;
		buf = new byte[capacity];
		}

		/**
		* Closes the reader by closing the underlying {@code InputStream} and
		* marking this reader as closed.
		*
		* @throws IOException for errors when closing the underlying {@code InputStream}.
		*/
		public void close() throws IOException {
		synchronized (in) {
		if (buf != null) {
		buf = null;
		in.close();
		}
		}
		}

		/**
		* Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
		* this end of line marker is not included in the result.
		*
		* @return the next line from the input.
		* @throws IOException for underlying {@code InputStream} errors.
		* @throws EOFException for the end of source stream.
		*/
		public String readLine() throws IOException {
		synchronized (in) {
		if (buf == null) {
		throw new IOException("LineReader is closed");
		}

		// Read more data if we are at the end of the buffered data.
		// Though it's an error to read after an exception, we will let {@code fillBuf()}
		// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
		if (pos >= end) {
		fillBuf();
		}
		// Try to find LF in the buffered data and return the line if successful.
		for (int i = pos; i != end; ++i) {
		if (buf[i] == LF) {
		int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
		String res = new String(buf, pos, lineEnd - pos, charset.name());
		pos = i + 1;
		return res;
		}
		}

		// Let's anticipate up to 80 characters on top of those already read.
		ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
		@Override
		public String toString() {
		int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
		try {
		return new String(buf, 0, length, charset.name());
		} catch (UnsupportedEncodingException e) {
		throw new AssertionError(e); // Since we control the charset this will never happen.
		}
		}
		};

		while (true) {
		out.write(buf, pos, end - pos);
		// Mark unterminated line in case fillBuf throws EOFException or IOException.
		end = -1;
		fillBuf();
		// Try to find LF in the buffered data and return the line if successful.
		for (int i = pos; i != end; ++i) {
		if (buf[i] == LF) {
		if (i != pos) {
		out.write(buf, pos, i - pos);
		}
		pos = i + 1;
		return out.toString();
		}
		}
		}
		}
		}

		public boolean hasUnterminatedLine() {
		return end == -1;
		}

		/**
		* Reads new input data into the buffer. Call only with pos == end or end == -1,
		* depending on the desired outcome if the function throws.
		*/
		private void fillBuf() throws IOException {
		int result = in.read(buf, 0, buf.length);
		if (result == -1) {
		throw new EOFException();
		}
		pos = 0;
		end = result;
		}
		}

src/org/lineageos/eleven/cache/disklrucache/Util.java

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed 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.lineageos.eleven.cache.disklrucache;

		import java.io.Closeable;
		import java.io.File;
		import java.io.IOException;
		import java.io.Reader;
		import java.io.StringWriter;
		import java.nio.charset.Charset;

		/** Junk drawer of utility methods. */
		final class Util {
		static final Charset US_ASCII = Charset.forName("US-ASCII");
		static final Charset UTF_8 = Charset.forName("UTF-8");

		private Util() {
		}

		static String readFully(Reader reader) throws IOException {
		try {
		StringWriter writer = new StringWriter();
		char[] buffer = new char[1024];
		int count;
		while ((count = reader.read(buffer)) != -1) {
		writer.write(buffer, 0, count);
		}
		return writer.toString();
		} finally {
		reader.close();
		}
		}

		/**
		* Deletes the contents of {@code dir}. Throws an IOException if any file
		* could not be deleted, or if {@code dir} is not a readable directory.
		*/
		static void deleteContents(File dir) throws IOException {
		File[] files = dir.listFiles();
		if (files == null) {
		throw new IOException("not a readable directory: " + dir);
		}
		for (File file : files) {
		if (file.isDirectory()) {
		deleteContents(file);
		}
		if (!file.delete()) {
		throw new IOException("failed to delete file: " + file);
		}
		}
		}

		static void closeQuietly(/Auto/Closeable closeable) {
		if (closeable != null) {
		try {
		closeable.close();
		} catch (RuntimeException rethrown) {
		throw rethrown;
		} catch (Exception ignored) {
		}
		}
		}
		}