- 4.0.0
-
- com.navercorp.pinpoint
- pinpoint
- ../..
- 1.6.1-SNAPSHOT
-
-
-
- pinpoint-google-guava
- pinpoint-google-guava
- jar
-
-
- 1.6
- ${env.JAVA_7_HOME}
- java16
-
-
-
-
-
-
- com.google.code.findbugs
- jsr305
- 1.3.9
- provided
-
-
- com.google.j2objc
- j2objc-annotations
- 1.1
- provided
-
-
- org.codehaus.mojo
- animal-sniffer-annotations
- 1.14
- provided
-
-
-
-
-
- org.slf4j
- slf4j-api
- test
-
-
- org.slf4j
- slf4j-log4j12
- test
-
-
- log4j
- log4j
- test
-
-
-
-
-
-
-
-
- org.codehaus.mojo
- build-helper-maven-plugin
- 1.10
-
-
- generate-sources
- add-source
-
- src/main/java-logging
-
-
-
-
-
-
- com.google.code.maven-replacer-plugin
- replacer
- 1.5.3
-
-
- generate-sources
-
- replace
-
-
-
-
- ${encoding}
- ${project.build.sourceDirectory}/
-
- **/*.java
-
-
-
-
-
-
- java.util.logging.
- com.google.common.logging.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Level.java b/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Level.java
deleted file mode 100644
index d30ce5b282dc..000000000000
--- a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Level.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2016 NAVER Corp.
- *
- * 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 com.google.common.logging;
-
-/**
- * compiler trick class
- * @author Woonduk Kang(emeroad)
- */
-public enum Level {
-
- OFF(Integer.MAX_VALUE),
- SEVERE(1000),
- WARNING(900),
- CONFIG(700),
- INFO(800),
- FINE(500),
- FINER(400),
- FINEST(300),
- ALL(Integer.MIN_VALUE);
-
-
-
- private final int level;
-
- Level(int level) {
- this.level = level;
- }
-
- public int intValue() {
- return level;
- }
-
- public String getName() {
- return name();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Logger.java b/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Logger.java
deleted file mode 100644
index 5c02001e05a5..000000000000
--- a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/Logger.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright 2016 NAVER Corp.
- *
- * 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 com.google.common.logging;
-
-
-import java.io.PrintStream;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.text.MessageFormat;
-
-/**
- * compiler trick class
- *
- * @author Woonduk Kang(emeroad)
- */
-public class Logger {
-
- private static Level DEFAULT_LOG_LEVEL;
-
- private final String name;
- private final String messagePattern;
- private final Level level;
-
- private final PrintStream out;
- private final PrintStream err;
-
- static {
- setup();
-
- }
-
- private static void setup() {
- // TODO setup log level
- DEFAULT_LOG_LEVEL = Level.INFO;
- }
-
- public static Logger getLogger(String name) {
- return new Logger(name, DEFAULT_LOG_LEVEL);
- }
-
- public Logger(String name, Level level) {
- this(name, level, System.out, System.err);
- }
-
- Logger(String name, Level level, PrintStream out, PrintStream err) {
- this.name = name;
- this.level = level;
- this.messagePattern = "{0,date,yyyy-MM-dd HH:mm:ss} [{1}](" + name + ") {2}{3}";
- this.out = out;
- this.err = err;
- }
-
- public String getName() {
- return name;
- }
-
- public void log(Level level, String msg) {
- if (!isLoggable(level)) {
- return;
- }
- doLog(level, msg, null, null);
- }
-
- public void log(Level level, String msg, Throwable throwable) {
- if (!isLoggable(level)) {
- return;
- }
- doLog(level, msg, null, throwable);
- }
-
- public void log(Level level, String msg, Object params[]) {
- if (!isLoggable(level)) {
- return;
- }
- doLog(level, msg, params, null);
- }
-
-
-
- public void log(Level level, String msg, Object param1) {
- if (!isLoggable(level)) {
- return;
- }
- doLog(level, msg, new Object[]{param1}, null);
- }
-
- private void doLog(Level level, String msg, Object[] params, Throwable throwable) {
-
- String format = messageFormat(msg, params);
-
- String exceptionMessage = toString(throwable);
- String logMessage = logFormat(level, format, exceptionMessage);
-
- PrintStream printStream = getPrintStream(level);
- printStream.println(logMessage);
-
- }
-
- private PrintStream getPrintStream(Level level) {
- if (level.intValue() >= Level.WARNING.intValue()) {
- return this.err;
- } else {
- return this.out;
- }
- }
-
- public boolean isLoggable(Level level) {
- if (level.intValue() < this.level.intValue()) {
- return false;
- }
- return true;
- }
-
- public void info(String msg) {
- Level logLevel = Level.INFO;
- if (!isLoggable(logLevel)) {
- return;
- }
- doLog(Level.INFO, msg, null, null);
- }
-
- public void warning(String msg) {
- if (!isLoggable(Level.WARNING)) {
- return;
- }
- doLog(Level.WARNING, msg, null, null);
- }
-
- private String messageFormat(String format, Object[] parameter) {
- if (parameter == null || parameter.length == 0) {
- return format;
- }
- // emulation java util.logging
- if (format.indexOf("{0") >= 0 || format.indexOf("{1") >= 0 || format.indexOf("{2") >= 0 || format.indexOf("{3") >= 0) {
- return MessageFormat.format(format, parameter);
- }
-
- return format;
- }
- private String logFormat(Level logLevel, String msg, String exceptionMessage) {
- exceptionMessage = defaultString(exceptionMessage, "");
-
- final long date = System.currentTimeMillis();
- return MessageFormat.format(messagePattern, date, logLevel.getName(), msg, exceptionMessage);
- }
-
- private String toString(Throwable throwable) {
- if (throwable == null) {
- return "";
- }
- StringWriter sw = new StringWriter();
- PrintWriter pw = new PrintWriter(sw);
- pw.println();
- throwable.printStackTrace(pw);
- pw.close();
- return sw.toString();
- }
-
- private String defaultString(String exceptionMessage, String defaultValue) {
- if (exceptionMessage == null) {
- return defaultValue;
- }
- return exceptionMessage;
- }
-
-}
diff --git a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/package-info.java b/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/package-info.java
deleted file mode 100644
index c61b39bbe60f..000000000000
--- a/thirdparty/google-guava/src/main/java-logging/com/google/common/logging/package-info.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2016 NAVER Corp.
- *
- * 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 com.google.common.logging;/*
-
-
-/**
- * compiler trick package
- */
-
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/annotations/Beta.java b/thirdparty/google-guava/src/main/java/com/google/common/annotations/Beta.java
deleted file mode 100644
index 5eefe9abd0ce..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/annotations/Beta.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2010 The Guava Authors
- *
- * 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 com.google.common.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Signifies that a public API (public class, method or field) is subject to
- * incompatible changes, or even removal, in a future release. An API bearing
- * this annotation is exempt from any compatibility guarantees made by its
- * containing library. Note that the presence of this annotation implies nothing
- * about the quality or performance of the API in question, only the fact that
- * it is not "API-frozen."
- *
- * It is generally safe for applications to depend on beta APIs, at
- * the cost of some extra work during upgrades. However it is generally
- * inadvisable for libraries (which get included on users' CLASSPATHs,
- * outside the library developers' control) to do so.
- *
- *
- * @author Kevin Bourrillion
- */
-@Retention(RetentionPolicy.CLASS)
-@Target({
- ElementType.ANNOTATION_TYPE,
- ElementType.CONSTRUCTOR,
- ElementType.FIELD,
- ElementType.METHOD,
- ElementType.TYPE})
-@Documented
-@GwtCompatible
-public @interface Beta {}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtCompatible.java b/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtCompatible.java
deleted file mode 100644
index 85bfa4df127f..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtCompatible.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2009 The Guava Authors
- *
- * 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 com.google.common.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * The presence of this annotation on a type indicates that the type may be
- * used with the
- * Google Web Toolkit (GWT).
- * When applied to a method, the return type of the method is GWT compatible.
- * It's useful to indicate that an instance created by factory methods has a GWT
- * serializable type. In the following example,
- *
- *
- * {@literal @}GwtCompatible
- * class Lists {
- * ...
- * {@literal @}GwtCompatible(serializable = true)
- * static <E> List<E> newArrayList(E... elements) {
- * ...
- * }
- * }
- *
- * The return value of {@code Lists.newArrayList(E[])} has GWT
- * serializable type. It is also useful in specifying contracts of interface
- * methods. In the following example,
- *
- *
- * {@literal @}GwtCompatible
- * interface ListFactory {
- * ...
- * {@literal @}GwtCompatible(serializable = true)
- * <E> List<E> newArrayList(E... elements);
- * }
- *
- * The {@code newArrayList(E[])} method of all implementations of {@code
- * ListFactory} is expected to return a value with a GWT serializable type.
- *
- *
Note that a {@code GwtCompatible} type may have some {@link
- * GwtIncompatible} methods.
- *
- * @author Charles Fry
- * @author Hayward Chan
- */
-@Retention(RetentionPolicy.CLASS)
-@Target({ ElementType.TYPE, ElementType.METHOD })
-@Documented
-@GwtCompatible
-public @interface GwtCompatible {
-
- /**
- * When {@code true}, the annotated type or the type of the method return
- * value is GWT serializable.
- *
- * @see
- * Documentation about GWT serialization
- */
- boolean serializable() default false;
-
- /**
- * When {@code true}, the annotated type is emulated in GWT. The emulated
- * source (also known as super-source) is different from the implementation
- * used by the JVM.
- *
- * @see
- * Documentation about GWT emulated source
- */
- boolean emulated() default false;
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtIncompatible.java b/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtIncompatible.java
deleted file mode 100644
index a56d746c8c08..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/annotations/GwtIncompatible.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2009 The Guava Authors
- *
- * 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 com.google.common.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * The presence of this annotation on a method indicates that the method may
- * not be used with the
- * Google Web Toolkit (GWT),
- * even though its type is annotated as {@link GwtCompatible} and accessible in
- * GWT. They can cause GWT compilation errors or simply unexpected exceptions
- * when used in GWT.
- *
- *
Note that this annotation should only be applied to methods, fields, or
- * inner classes of types which are annotated as {@link GwtCompatible}.
- *
- * @author Charles Fry
- */
-@Retention(RetentionPolicy.CLASS)
-@Target({
- ElementType.TYPE, ElementType.METHOD,
- ElementType.CONSTRUCTOR, ElementType.FIELD })
-@Documented
-@GwtCompatible
-public @interface GwtIncompatible {
- /**
- * Describes why the annotated element is incompatible with GWT. Since this is
- * generally due to a dependence on a type/method which GWT doesn't support,
- * it is sufficient to simply reference the unsupported type/method. E.g.
- * "Class.isInstance".
- */
- String value();
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/annotations/VisibleForTesting.java b/thirdparty/google-guava/src/main/java/com/google/common/annotations/VisibleForTesting.java
deleted file mode 100644
index 6f867db3adb7..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/annotations/VisibleForTesting.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2006 The Guava Authors
- *
- * 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 com.google.common.annotations;
-
-/**
- * Annotates a program element that exists, or is more widely visible than
- * otherwise necessary, only for use in test code.
- *
- * @author Johannes Henkel
- */
-@GwtCompatible
-public @interface VisibleForTesting {
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/annotations/package-info.java b/thirdparty/google-guava/src/main/java/com/google/common/annotations/package-info.java
deleted file mode 100644
index 2bf8b218c78d..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/annotations/package-info.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2010 The Guava Authors
- *
- * 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.
- */
-
-/**
- * Common annotation types. This package is a part of the open-source
- * Guava libraries .
- */
-package com.google.common.annotations;
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Absent.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Absent.java
deleted file mode 100644
index a60762187e4f..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Absent.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.util.Collections;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-/**
- * Implementation of an {@link Optional} not containing a reference.
- */
-@GwtCompatible
-final class Absent extends Optional {
- static final Absent INSTANCE = new Absent();
-
- @SuppressWarnings("unchecked") // implementation is "fully variant"
- static Optional withType() {
- return (Optional) INSTANCE;
- }
-
- private Absent() {}
-
- @Override
- public boolean isPresent() {
- return false;
- }
-
- @Override
- public T get() {
- throw new IllegalStateException("Optional.get() cannot be called on an absent value");
- }
-
- @Override
- public T or(T defaultValue) {
- return checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
- }
-
- @SuppressWarnings("unchecked") // safe covariant cast
- @Override
- public Optional or(Optional secondChoice) {
- return (Optional) checkNotNull(secondChoice);
- }
-
- @Override
- public T or(Supplier supplier) {
- return checkNotNull(
- supplier.get(), "use Optional.orNull() instead of a Supplier that returns null");
- }
-
- @Override
- @Nullable
- public T orNull() {
- return null;
- }
-
- @Override
- public Set asSet() {
- return Collections.emptySet();
- }
-
- @Override
- public Optional transform(Function function) {
- checkNotNull(function);
- return Optional.absent();
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- return object == this;
- }
-
- @Override
- public int hashCode() {
- return 0x79a31aac;
- }
-
- @Override
- public String toString() {
- return "Optional.absent()";
- }
-
- private Object readResolve() {
- return INSTANCE;
- }
-
- private static final long serialVersionUID = 0;
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/AbstractIterator.java b/thirdparty/google-guava/src/main/java/com/google/common/base/AbstractIterator.java
deleted file mode 100644
index 7b29fea1d530..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/AbstractIterator.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkState;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-/**
- * Note this class is a copy of
- * {@link com.google.common.collect.AbstractIterator} (for dependency reasons).
- */
-@GwtCompatible
-abstract class AbstractIterator implements Iterator {
- private State state = State.NOT_READY;
-
- protected AbstractIterator() {}
-
- private enum State {
- READY,
- NOT_READY,
- DONE,
- FAILED,
- }
-
- private T next;
-
- protected abstract T computeNext();
-
- protected final T endOfData() {
- state = State.DONE;
- return null;
- }
-
- @Override
- public final boolean hasNext() {
- checkState(state != State.FAILED);
- switch (state) {
- case READY:
- return true;
- case DONE:
- return false;
- default:
- }
- return tryToComputeNext();
- }
-
- private boolean tryToComputeNext() {
- state = State.FAILED; // temporary pessimism
- next = computeNext();
- if (state != State.DONE) {
- state = State.READY;
- return true;
- }
- return false;
- }
-
- @Override
- public final T next() {
- if (!hasNext()) {
- throw new NoSuchElementException();
- }
- state = State.NOT_READY;
- T result = next;
- next = null;
- return result;
- }
-
- @Override
- public final void remove() {
- throw new UnsupportedOperationException();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Ascii.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Ascii.java
deleted file mode 100644
index 9024290ba54a..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Ascii.java
+++ /dev/null
@@ -1,669 +0,0 @@
-/*
- * Copyright (C) 2010 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import javax.annotation.CheckReturnValue;
-
-/**
- * Static methods pertaining to ASCII characters (those in the range of values
- * {@code 0x00} through {@code 0x7F}), and to strings containing such
- * characters.
- *
- * ASCII utilities also exist in other classes of this package:
- *
- *
- * {@link Charsets#US_ASCII} specifies the {@code Charset} of ASCII characters.
- * {@link CharMatcher#ASCII} matches ASCII characters and provides text processing methods
- * which operate only on the ASCII characters of a string.
- *
- *
- * @author Craig Berry
- * @author Gregory Kick
- * @since 7.0
- */
-@CheckReturnValue
-@GwtCompatible
-public final class Ascii {
-
- private Ascii() {}
-
- /* The ASCII control characters, per RFC 20. */
- /**
- * Null ('\0'): The all-zeros character which may serve to accomplish
- * time fill and media fill. Normally used as a C string terminator.
- * Although RFC 20 names this as "Null", note that it is distinct
- * from the C/C++ "NULL" pointer.
- *
- * @since 8.0
- */
- public static final byte NUL = 0;
-
- /**
- * Start of Heading: A communication control character used at
- * the beginning of a sequence of characters which constitute a
- * machine-sensible address or routing information. Such a sequence is
- * referred to as the "heading." An STX character has the effect of
- * terminating a heading.
- *
- * @since 8.0
- */
- public static final byte SOH = 1;
-
- /**
- * Start of Text: A communication control character which
- * precedes a sequence of characters that is to be treated as an entity
- * and entirely transmitted through to the ultimate destination. Such a
- * sequence is referred to as "text." STX may be used to terminate a
- * sequence of characters started by SOH.
- *
- * @since 8.0
- */
- public static final byte STX = 2;
-
- /**
- * End of Text: A communication control character used to
- * terminate a sequence of characters started with STX and transmitted
- * as an entity.
- *
- * @since 8.0
- */
- public static final byte ETX = 3;
-
- /**
- * End of Transmission: A communication control character used
- * to indicate the conclusion of a transmission, which may have
- * contained one or more texts and any associated headings.
- *
- * @since 8.0
- */
- public static final byte EOT = 4;
-
- /**
- * Enquiry: A communication control character used in data
- * communication systems as a request for a response from a remote
- * station. It may be used as a "Who Are You" (WRU) to obtain
- * identification, or may be used to obtain station status, or both.
- *
- * @since 8.0
- */
- public static final byte ENQ = 5;
-
- /**
- * Acknowledge: A communication control character transmitted
- * by a receiver as an affirmative response to a sender.
- *
- * @since 8.0
- */
- public static final byte ACK = 6;
-
- /**
- * Bell ('\a'): A character for use when there is a need to call for
- * human attention. It may control alarm or attention devices.
- *
- * @since 8.0
- */
- public static final byte BEL = 7;
-
- /**
- * Backspace ('\b'): A format effector which controls the movement of
- * the printing position one printing space backward on the same
- * printing line. (Applicable also to display devices.)
- *
- * @since 8.0
- */
- public static final byte BS = 8;
-
- /**
- * Horizontal Tabulation ('\t'): A format effector which controls the
- * movement of the printing position to the next in a series of
- * predetermined positions along the printing line. (Applicable also to
- * display devices and the skip function on punched cards.)
- *
- * @since 8.0
- */
- public static final byte HT = 9;
-
- /**
- * Line Feed ('\n'): A format effector which controls the movement of
- * the printing position to the next printing line. (Applicable also to
- * display devices.) Where appropriate, this character may have the
- * meaning "New Line" (NL), a format effector which controls the
- * movement of the printing point to the first printing position on the
- * next printing line. Use of this convention requires agreement
- * between sender and recipient of data.
- *
- * @since 8.0
- */
- public static final byte LF = 10;
-
- /**
- * Alternate name for {@link #LF}. ({@code LF} is preferred.)
- *
- * @since 8.0
- */
- public static final byte NL = 10;
-
- /**
- * Vertical Tabulation ('\v'): A format effector which controls the
- * movement of the printing position to the next in a series of
- * predetermined printing lines. (Applicable also to display devices.)
- *
- * @since 8.0
- */
- public static final byte VT = 11;
-
- /**
- * Form Feed ('\f'): A format effector which controls the movement of
- * the printing position to the first pre-determined printing line on
- * the next form or page. (Applicable also to display devices.)
- *
- * @since 8.0
- */
- public static final byte FF = 12;
-
- /**
- * Carriage Return ('\r'): A format effector which controls the
- * movement of the printing position to the first printing position on
- * the same printing line. (Applicable also to display devices.)
- *
- * @since 8.0
- */
- public static final byte CR = 13;
-
- /**
- * Shift Out: A control character indicating that the code
- * combinations which follow shall be interpreted as outside of the
- * character set of the standard code table until a Shift In character
- * is reached.
- *
- * @since 8.0
- */
- public static final byte SO = 14;
-
- /**
- * Shift In: A control character indicating that the code
- * combinations which follow shall be interpreted according to the
- * standard code table.
- *
- * @since 8.0
- */
- public static final byte SI = 15;
-
- /**
- * Data Link Escape: A communication control character which
- * will change the meaning of a limited number of contiguously following
- * characters. It is used exclusively to provide supplementary controls
- * in data communication networks.
- *
- * @since 8.0
- */
- public static final byte DLE = 16;
-
- /**
- * Device Control 1. Characters for the control
- * of ancillary devices associated with data processing or
- * telecommunication systems, more especially switching devices "on" or
- * "off." (If a single "stop" control is required to interrupt or turn
- * off ancillary devices, DC4 is the preferred assignment.)
- *
- * @since 8.0
- */
- public static final byte DC1 = 17; // aka XON
-
- /**
- * Transmission On: Although originally defined as DC1, this ASCII
- * control character is now better known as the XON code used for software
- * flow control in serial communications. The main use is restarting
- * the transmission after the communication has been stopped by the XOFF
- * control code.
- *
- * @since 8.0
- */
- public static final byte XON = 17; // aka DC1
-
- /**
- * Device Control 2. Characters for the control
- * of ancillary devices associated with data processing or
- * telecommunication systems, more especially switching devices "on" or
- * "off." (If a single "stop" control is required to interrupt or turn
- * off ancillary devices, DC4 is the preferred assignment.)
- *
- * @since 8.0
- */
- public static final byte DC2 = 18;
-
- /**
- * Device Control 3. Characters for the control
- * of ancillary devices associated with data processing or
- * telecommunication systems, more especially switching devices "on" or
- * "off." (If a single "stop" control is required to interrupt or turn
- * off ancillary devices, DC4 is the preferred assignment.)
- *
- * @since 8.0
- */
- public static final byte DC3 = 19; // aka XOFF
-
- /**
- * Transmission off. See {@link #XON} for explanation.
- *
- * @since 8.0
- */
- public static final byte XOFF = 19; // aka DC3
-
- /**
- * Device Control 4. Characters for the control
- * of ancillary devices associated with data processing or
- * telecommunication systems, more especially switching devices "on" or
- * "off." (If a single "stop" control is required to interrupt or turn
- * off ancillary devices, DC4 is the preferred assignment.)
- *
- * @since 8.0
- */
- public static final byte DC4 = 20;
-
- /**
- * Negative Acknowledge: A communication control character
- * transmitted by a receiver as a negative response to the sender.
- *
- * @since 8.0
- */
- public static final byte NAK = 21;
-
- /**
- * Synchronous Idle: A communication control character used by
- * a synchronous transmission system in the absence of any other
- * character to provide a signal from which synchronism may be achieved
- * or retained.
- *
- * @since 8.0
- */
- public static final byte SYN = 22;
-
- /**
- * End of Transmission Block: A communication control character
- * used to indicate the end of a block of data for communication
- * purposes. ETB is used for blocking data where the block structure is
- * not necessarily related to the processing format.
- *
- * @since 8.0
- */
- public static final byte ETB = 23;
-
- /**
- * Cancel: A control character used to indicate that the data
- * with which it is sent is in error or is to be disregarded.
- *
- * @since 8.0
- */
- public static final byte CAN = 24;
-
- /**
- * End of Medium: A control character associated with the sent
- * data which may be used to identify the physical end of the medium, or
- * the end of the used, or wanted, portion of information recorded on a
- * medium. (The position of this character does not necessarily
- * correspond to the physical end of the medium.)
- *
- * @since 8.0
- */
- public static final byte EM = 25;
-
- /**
- * Substitute: A character that may be substituted for a
- * character which is determined to be invalid or in error.
- *
- * @since 8.0
- */
- public static final byte SUB = 26;
-
- /**
- * Escape: A control character intended to provide code
- * extension (supplementary characters) in general information
- * interchange. The Escape character itself is a prefix affecting the
- * interpretation of a limited number of contiguously following
- * characters.
- *
- * @since 8.0
- */
- public static final byte ESC = 27;
-
- /**
- * File Separator: These four information separators may be
- * used within data in optional fashion, except that their hierarchical
- * relationship shall be: FS is the most inclusive, then GS, then RS,
- * and US is least inclusive. (The content and length of a File, Group,
- * Record, or Unit are not specified.)
- *
- * @since 8.0
- */
- public static final byte FS = 28;
-
- /**
- * Group Separator: These four information separators may be
- * used within data in optional fashion, except that their hierarchical
- * relationship shall be: FS is the most inclusive, then GS, then RS,
- * and US is least inclusive. (The content and length of a File, Group,
- * Record, or Unit are not specified.)
- *
- * @since 8.0
- */
- public static final byte GS = 29;
-
- /**
- * Record Separator: These four information separators may be
- * used within data in optional fashion, except that their hierarchical
- * relationship shall be: FS is the most inclusive, then GS, then RS,
- * and US is least inclusive. (The content and length of a File, Group,
- * Record, or Unit are not specified.)
- *
- * @since 8.0
- */
- public static final byte RS = 30;
-
- /**
- * Unit Separator: These four information separators may be
- * used within data in optional fashion, except that their hierarchical
- * relationship shall be: FS is the most inclusive, then GS, then RS,
- * and US is least inclusive. (The content and length of a File, Group,
- * Record, or Unit are not specified.)
- *
- * @since 8.0
- */
- public static final byte US = 31;
-
- /**
- * Space: A normally non-printing graphic character used to
- * separate words. It is also a format effector which controls the
- * movement of the printing position, one printing position forward.
- * (Applicable also to display devices.)
- *
- * @since 8.0
- */
- public static final byte SP = 32;
-
- /**
- * Alternate name for {@link #SP}.
- *
- * @since 8.0
- */
- public static final byte SPACE = 32;
-
- /**
- * Delete: This character is used primarily to "erase" or
- * "obliterate" erroneous or unwanted characters in perforated tape.
- *
- * @since 8.0
- */
- public static final byte DEL = 127;
-
- /**
- * The minimum value of an ASCII character.
- *
- * @since 9.0 (was type {@code int} before 12.0)
- */
- public static final char MIN = 0;
-
- /**
- * The maximum value of an ASCII character.
- *
- * @since 9.0 (was type {@code int} before 12.0)
- */
- public static final char MAX = 127;
-
- /**
- * Returns a copy of the input string in which all {@linkplain #isUpperCase(char) uppercase ASCII
- * characters} have been converted to lowercase. All other characters are copied without
- * modification.
- */
- public static String toLowerCase(String string) {
- int length = string.length();
- for (int i = 0; i < length; i++) {
- if (isUpperCase(string.charAt(i))) {
- char[] chars = string.toCharArray();
- for (; i < length; i++) {
- char c = chars[i];
- if (isUpperCase(c)) {
- chars[i] = (char) (c ^ 0x20);
- }
- }
- return String.valueOf(chars);
- }
- }
- return string;
- }
-
- /**
- * Returns a copy of the input character sequence in which all {@linkplain #isUpperCase(char)
- * uppercase ASCII characters} have been converted to lowercase. All other characters are copied
- * without modification.
- *
- * @since 14.0
- */
- public static String toLowerCase(CharSequence chars) {
- if (chars instanceof String) {
- return toLowerCase((String) chars);
- }
- int length = chars.length();
- StringBuilder builder = new StringBuilder(length);
- for (int i = 0; i < length; i++) {
- builder.append(toLowerCase(chars.charAt(i)));
- }
- return builder.toString();
- }
-
- /**
- * If the argument is an {@linkplain #isUpperCase(char) uppercase ASCII character} returns the
- * lowercase equivalent. Otherwise returns the argument.
- */
- public static char toLowerCase(char c) {
- return isUpperCase(c) ? (char) (c ^ 0x20) : c;
- }
-
- /**
- * Returns a copy of the input string in which all {@linkplain #isLowerCase(char) lowercase ASCII
- * characters} have been converted to uppercase. All other characters are copied without
- * modification.
- */
- public static String toUpperCase(String string) {
- int length = string.length();
- for (int i = 0; i < length; i++) {
- if (isLowerCase(string.charAt(i))) {
- char[] chars = string.toCharArray();
- for (; i < length; i++) {
- char c = chars[i];
- if (isLowerCase(c)) {
- chars[i] = (char) (c & 0x5f);
- }
- }
- return String.valueOf(chars);
- }
- }
- return string;
- }
-
- /**
- * Returns a copy of the input character sequence in which all {@linkplain #isLowerCase(char)
- * lowercase ASCII characters} have been converted to uppercase. All other characters are copied
- * without modification.
- *
- * @since 14.0
- */
- public static String toUpperCase(CharSequence chars) {
- if (chars instanceof String) {
- return toUpperCase((String) chars);
- }
- int length = chars.length();
- StringBuilder builder = new StringBuilder(length);
- for (int i = 0; i < length; i++) {
- builder.append(toUpperCase(chars.charAt(i)));
- }
- return builder.toString();
- }
-
- /**
- * If the argument is a {@linkplain #isLowerCase(char) lowercase ASCII character} returns the
- * uppercase equivalent. Otherwise returns the argument.
- */
- public static char toUpperCase(char c) {
- return isLowerCase(c) ? (char) (c & 0x5f) : c;
- }
-
- /**
- * Indicates whether {@code c} is one of the twenty-six lowercase ASCII alphabetic characters
- * between {@code 'a'} and {@code 'z'} inclusive. All others (including non-ASCII characters)
- * return {@code false}.
- */
- public static boolean isLowerCase(char c) {
- // Note: This was benchmarked against the alternate expression "(char)(c - 'a') < 26" (Nov '13)
- // and found to perform at least as well, or better.
- return (c >= 'a') && (c <= 'z');
- }
-
- /**
- * Indicates whether {@code c} is one of the twenty-six uppercase ASCII alphabetic characters
- * between {@code 'A'} and {@code 'Z'} inclusive. All others (including non-ASCII characters)
- * return {@code false}.
- */
- public static boolean isUpperCase(char c) {
- return (c >= 'A') && (c <= 'Z');
- }
-
- /**
- * Truncates the given character sequence to the given maximum length. If the length of the
- * sequence is greater than {@code maxLength}, the returned string will be exactly
- * {@code maxLength} chars in length and will end with the given {@code truncationIndicator}.
- * Otherwise, the sequence will be returned as a string with no changes to the content.
- *
- *
Examples:
- *
- *
{@code
- * Ascii.truncate("foobar", 7, "..."); // returns "foobar"
- * Ascii.truncate("foobar", 5, "..."); // returns "fo..." }
- *
- * Note: This method may work with certain non-ASCII text but is not safe for
- * use with arbitrary Unicode text. It is mostly intended for use with text that is known to be
- * safe for use with it (such as all-ASCII text) and for simple debugging text. When using this
- * method, consider the following:
- *
- *
- * it may split surrogate pairs
- * it may split characters and combining characters
- * it does not consider word boundaries
- * if truncating for display to users, there are other considerations that must be taken
- * into account
- * the appropriate truncation indicator may be locale-dependent
- * it is safe to use non-ASCII characters in the truncation indicator
- *
- *
- *
- * @throws IllegalArgumentException if {@code maxLength} is less than the length of
- * {@code truncationIndicator}
- * @since 16.0
- */
- @Beta
- public static String truncate(CharSequence seq, int maxLength, String truncationIndicator) {
- checkNotNull(seq);
-
- // length to truncate the sequence to, not including the truncation indicator
- int truncationLength = maxLength - truncationIndicator.length();
-
- // in this worst case, this allows a maxLength equal to the length of the truncationIndicator,
- // meaning that a string will be truncated to just the truncation indicator itself
- checkArgument(
- truncationLength >= 0,
- "maxLength (%s) must be >= length of the truncation indicator (%s)",
- maxLength,
- truncationIndicator.length());
-
- if (seq.length() <= maxLength) {
- String string = seq.toString();
- if (string.length() <= maxLength) {
- return string;
- }
- // if the length of the toString() result was > maxLength for some reason, truncate that
- seq = string;
- }
-
- return new StringBuilder(maxLength)
- .append(seq, 0, truncationLength)
- .append(truncationIndicator)
- .toString();
- }
-
- /**
- * Indicates whether the contents of the given character sequences {@code s1} and {@code s2} are
- * equal, ignoring the case of any ASCII alphabetic characters between {@code 'a'} and {@code 'z'}
- * or {@code 'A'} and {@code 'Z'} inclusive.
- *
- * This method is significantly faster than {@link String#equalsIgnoreCase} and should be used
- * in preference if at least one of the parameters is known to contain only ASCII characters.
- *
- *
Note however that this method does not always behave identically to expressions such as:
- *
- * {@code string.toUpperCase().equals("UPPER CASE ASCII")}
- * {@code string.toLowerCase().equals("lower case ascii")}
- *
- * due to case-folding of some non-ASCII characters (which does not occur in
- * {@link String#equalsIgnoreCase}). However in almost all cases that ASCII strings are used,
- * the author probably wanted the behavior provided by this method rather than the subtle and
- * sometimes surprising behavior of {@code toUpperCase()} and {@code toLowerCase()}.
- *
- * @since 16.0
- */
- @Beta
- public static boolean equalsIgnoreCase(CharSequence s1, CharSequence s2) {
- // Calling length() is the null pointer check (so do it before we can exit early).
- int length = s1.length();
- if (s1 == s2) {
- return true;
- }
- if (length != s2.length()) {
- return false;
- }
- for (int i = 0; i < length; i++) {
- char c1 = s1.charAt(i);
- char c2 = s2.charAt(i);
- if (c1 == c2) {
- continue;
- }
- int alphaIndex = getAlphaIndex(c1);
- // This was also benchmarked using '&' to avoid branching (but always evaluate the rhs),
- // however this showed no obvious improvement.
- if (alphaIndex < 26 && alphaIndex == getAlphaIndex(c2)) {
- continue;
- }
- return false;
- }
- return true;
- }
-
- /**
- * Returns the non-negative index value of the alpha character {@code c}, regardless of case.
- * Ie, 'a'/'A' returns 0 and 'z'/'Z' returns 25. Non-alpha characters return a value of 26 or
- * greater.
- */
- private static int getAlphaIndex(char c) {
- // Fold upper-case ASCII to lower-case and make zero-indexed and unsigned (by casting to char).
- return (char) ((c | 0x20) - 'a');
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/CaseFormat.java b/thirdparty/google-guava/src/main/java/com/google/common/base/CaseFormat.java
deleted file mode 100644
index c074de26ae1b..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/CaseFormat.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (C) 2006 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Utility class for converting between various ASCII case formats. Behavior is undefined for
- * non-ASCII input.
- *
- * @author Mike Bostock
- * @since 1.0
- */
-@CheckReturnValue
-@GwtCompatible
-public enum CaseFormat {
- /**
- * Hyphenated variable naming convention, e.g., "lower-hyphen".
- */
- LOWER_HYPHEN(CharMatcher.is('-'), "-") {
- @Override
- String normalizeWord(String word) {
- return Ascii.toLowerCase(word);
- }
-
- @Override
- String convert(CaseFormat format, String s) {
- if (format == LOWER_UNDERSCORE) {
- return s.replace('-', '_');
- }
- if (format == UPPER_UNDERSCORE) {
- return Ascii.toUpperCase(s.replace('-', '_'));
- }
- return super.convert(format, s);
- }
- },
-
- /**
- * C++ variable naming convention, e.g., "lower_underscore".
- */
- LOWER_UNDERSCORE(CharMatcher.is('_'), "_") {
- @Override
- String normalizeWord(String word) {
- return Ascii.toLowerCase(word);
- }
-
- @Override
- String convert(CaseFormat format, String s) {
- if (format == LOWER_HYPHEN) {
- return s.replace('_', '-');
- }
- if (format == UPPER_UNDERSCORE) {
- return Ascii.toUpperCase(s);
- }
- return super.convert(format, s);
- }
- },
-
- /**
- * Java variable naming convention, e.g., "lowerCamel".
- */
- LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
- @Override
- String normalizeWord(String word) {
- return firstCharOnlyToUpper(word);
- }
- },
-
- /**
- * Java and C++ class naming convention, e.g., "UpperCamel".
- */
- UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
- @Override
- String normalizeWord(String word) {
- return firstCharOnlyToUpper(word);
- }
- },
-
- /**
- * Java and C++ constant naming convention, e.g., "UPPER_UNDERSCORE".
- */
- UPPER_UNDERSCORE(CharMatcher.is('_'), "_") {
- @Override
- String normalizeWord(String word) {
- return Ascii.toUpperCase(word);
- }
-
- @Override
- String convert(CaseFormat format, String s) {
- if (format == LOWER_HYPHEN) {
- return Ascii.toLowerCase(s.replace('_', '-'));
- }
- if (format == LOWER_UNDERSCORE) {
- return Ascii.toLowerCase(s);
- }
- return super.convert(format, s);
- }
- };
-
- private final CharMatcher wordBoundary;
- private final String wordSeparator;
-
- CaseFormat(CharMatcher wordBoundary, String wordSeparator) {
- this.wordBoundary = wordBoundary;
- this.wordSeparator = wordSeparator;
- }
-
- /**
- * Converts the specified {@code String str} from this format to the specified {@code format}. A
- * "best effort" approach is taken; if {@code str} does not conform to the assumed format, then
- * the behavior of this method is undefined but we make a reasonable effort at converting anyway.
- */
- public final String to(CaseFormat format, String str) {
- checkNotNull(format);
- checkNotNull(str);
- return (format == this) ? str : convert(format, str);
- }
-
- /**
- * Enum values can override for performance reasons.
- */
- String convert(CaseFormat format, String s) {
- // deal with camel conversion
- StringBuilder out = null;
- int i = 0;
- int j = -1;
- while ((j = wordBoundary.indexIn(s, ++j)) != -1) {
- if (i == 0) {
- // include some extra space for separators
- out = new StringBuilder(s.length() + 4 * wordSeparator.length());
- out.append(format.normalizeFirstWord(s.substring(i, j)));
- } else {
- out.append(format.normalizeWord(s.substring(i, j)));
- }
- out.append(format.wordSeparator);
- i = j + wordSeparator.length();
- }
- return (i == 0)
- ? format.normalizeFirstWord(s)
- : out.append(format.normalizeWord(s.substring(i))).toString();
- }
-
- /**
- * Returns a {@code Converter} that converts strings from this format to {@code targetFormat}.
- *
- * @since 16.0
- */
- @Beta
- public Converter converterTo(CaseFormat targetFormat) {
- return new StringConverter(this, targetFormat);
- }
-
- private static final class StringConverter extends Converter
- implements Serializable {
-
- private final CaseFormat sourceFormat;
- private final CaseFormat targetFormat;
-
- StringConverter(CaseFormat sourceFormat, CaseFormat targetFormat) {
- this.sourceFormat = checkNotNull(sourceFormat);
- this.targetFormat = checkNotNull(targetFormat);
- }
-
- @Override
- protected String doForward(String s) {
- return sourceFormat.to(targetFormat, s);
- }
-
- @Override
- protected String doBackward(String s) {
- return targetFormat.to(sourceFormat, s);
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof StringConverter) {
- StringConverter that = (StringConverter) object;
- return sourceFormat.equals(that.sourceFormat) && targetFormat.equals(that.targetFormat);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return sourceFormat.hashCode() ^ targetFormat.hashCode();
- }
-
- @Override
- public String toString() {
- return sourceFormat + ".converterTo(" + targetFormat + ")";
- }
-
- private static final long serialVersionUID = 0L;
- }
-
- abstract String normalizeWord(String word);
-
- private String normalizeFirstWord(String word) {
- return (this == LOWER_CAMEL) ? Ascii.toLowerCase(word) : normalizeWord(word);
- }
-
- private static String firstCharOnlyToUpper(String word) {
- return (word.isEmpty())
- ? word
- : new StringBuilder(word.length())
- .append(Ascii.toUpperCase(word.charAt(0)))
- .append(Ascii.toLowerCase(word.substring(1)))
- .toString();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/CharMatcher.java b/thirdparty/google-guava/src/main/java/com/google/common/base/CharMatcher.java
deleted file mode 100644
index 7e732dd9ece8..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/CharMatcher.java
+++ /dev/null
@@ -1,1826 +0,0 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkPositionIndex;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-import com.google.common.annotations.GwtIncompatible;
-import com.google.common.annotations.VisibleForTesting;
-
-import java.util.Arrays;
-import java.util.BitSet;
-
-import javax.annotation.CheckReturnValue;
-
-/**
- * Determines a true or false value for any Java {@code char} value, just as {@link Predicate} does
- * for any {@link Object}. Also offers basic text processing methods based on this function.
- * Implementations are strongly encouraged to be side-effect-free and immutable.
- *
- * Throughout the documentation of this class, the phrase "matching character" is used to mean
- * "any character {@code c} for which {@code this.matches(c)} returns {@code true}".
- *
- *
Note: This class deals only with {@code char} values; it does not understand
- * supplementary Unicode code points in the range {@code 0x10000} to {@code 0x10FFFF}. Such logical
- * characters are encoded into a {@code String} using surrogate pairs, and a {@code CharMatcher}
- * treats these just as two separate characters.
- *
- *
Example usages:
- * String trimmed = {@link #whitespace() whitespace()}.{@link #trimFrom trimFrom}(userInput);
- * if ({@link #ascii() ascii()}.{@link #matchesAllOf matchesAllOf}(s)) { ... }
- *
- * See the Guava User Guide article on
- * {@code CharMatcher} .
- *
- * @author Kevin Bourrillion
- * @since 1.0
- */
-@Beta // Possibly change from chars to code points; decide constants vs. methods
-@GwtCompatible(emulated = true)
-public abstract class CharMatcher implements Predicate {
-
- // Constant matcher factory methods
-
- /**
- * Matches any character.
- *
- * @since 19.0 (since 1.0 as constant {@code ANY})
- */
- public static CharMatcher any() {
- return Any.INSTANCE;
- }
-
- /**
- * Matches no characters.
- *
- * @since 19.0 (since 1.0 as constant {@code NONE})
- */
- public static CharMatcher none() {
- return None.INSTANCE;
- }
-
- /**
- * Determines whether a character is whitespace according to the latest Unicode standard, as
- * illustrated here .
- * This is not the same definition used by other Java APIs. (See a comparison of several
- * definitions of "whitespace" .)
- *
- * Note: as the Unicode definition evolves, we will modify this matcher to keep it up
- * to date.
- *
- * @since 19.0 (since 1.0 as constant {@code WHITESPACE})
- */
- public static CharMatcher whitespace() {
- return Whitespace.INSTANCE;
- }
-
- /**
- * Determines whether a character is a breaking whitespace (that is, a whitespace which can be
- * interpreted as a break between words for formatting purposes). See {@link #whitespace()} for a
- * discussion of that term.
- *
- * @since 19.0 (since 2.0 as constant {@code BREAKING_WHITESPACE})
- */
- public static CharMatcher breakingWhitespace() {
- return BreakingWhitespace.INSTANCE;
- }
-
- /**
- * Determines whether a character is ASCII, meaning that its code point is less than 128.
- *
- * @since 19.0 (since 1.0 as constant {@code ASCII})
- */
- public static CharMatcher ascii() {
- return Ascii.INSTANCE;
- }
-
- /**
- * Determines whether a character is a digit according to
- * Unicode .
- * If you only care to match ASCII digits, you can use {@code inRange('0', '9')}.
- *
- * @since 19.0 (since 1.0 as constant {@code DIGIT})
- */
- public static CharMatcher digit() {
- return Digit.INSTANCE;
- }
-
- /**
- * Determines whether a character is a digit according to {@linkplain Character#isDigit(char)
- * Java's definition}. If you only care to match ASCII digits, you can use {@code inRange('0',
- * '9')}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_DIGIT})
- */
- public static CharMatcher javaDigit() {
- return JavaDigit.INSTANCE;
- }
-
- /**
- * Determines whether a character is a letter according to {@linkplain Character#isLetter(char)
- * Java's definition}. If you only care to match letters of the Latin alphabet, you can use {@code
- * inRange('a', 'z').or(inRange('A', 'Z'))}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_LETTER})
- */
- public static CharMatcher javaLetter() {
- return JavaLetter.INSTANCE;
- }
-
- /**
- * Determines whether a character is a letter or digit according to {@linkplain
- * Character#isLetterOrDigit(char) Java's definition}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_LETTER_OR_DIGIT}).
- */
- public static CharMatcher javaLetterOrDigit() {
- return JavaLetterOrDigit.INSTANCE;
- }
-
- /**
- * Determines whether a character is upper case according to {@linkplain
- * Character#isUpperCase(char) Java's definition}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_UPPER_CASE})
- */
- public static CharMatcher javaUpperCase() {
- return JavaUpperCase.INSTANCE;
- }
-
- /**
- * Determines whether a character is lower case according to {@linkplain
- * Character#isLowerCase(char) Java's definition}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_LOWER_CASE})
- */
- public static CharMatcher javaLowerCase() {
- return JavaLowerCase.INSTANCE;
- }
-
- /**
- * Determines whether a character is an ISO control character as specified by {@link
- * Character#isISOControl(char)}.
- *
- * @since 19.0 (since 1.0 as constant {@code JAVA_ISO_CONTROL})
- */
- public static CharMatcher javaIsoControl() {
- return JavaIsoControl.INSTANCE;
- }
-
- /**
- * Determines whether a character is invisible; that is, if its Unicode category is any of
- * SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, SURROGATE, and
- * PRIVATE_USE according to ICU4J.
- *
- * @since 19.0 (since 1.0 as constant {@code INVISIBLE})
- */
- public static CharMatcher invisible() {
- return Invisible.INSTANCE;
- }
-
- /**
- * Determines whether a character is single-width (not double-width). When in doubt, this matcher
- * errs on the side of returning {@code false} (that is, it tends to assume a character is
- * double-width).
- *
- *
Note: as the reference file evolves, we will modify this matcher to keep it up to
- * date.
- *
- * @since 19.0 (since 1.0 as constant {@code SINGLE_WIDTH})
- */
- public static CharMatcher singleWidth() {
- return SingleWidth.INSTANCE;
- }
-
- // Legacy constants
- // TODO(cgdecker): Deprecate these so they can be removed eventually
-
- /**
- * Determines whether a character is whitespace according to the latest Unicode standard, as
- * illustrated here .
- * This is not the same definition used by other Java APIs. (See a comparison of several
- * definitions of "whitespace" .)
- *
- *
Note: as the Unicode definition evolves, we will modify this constant to keep it up
- * to date.
- */
- public static final CharMatcher WHITESPACE = whitespace();
-
- /**
- * Determines whether a character is a breaking whitespace (that is, a whitespace which can be
- * interpreted as a break between words for formatting purposes). See {@link #WHITESPACE} for a
- * discussion of that term.
- *
- * @since 2.0
- */
- public static final CharMatcher BREAKING_WHITESPACE = breakingWhitespace();
-
- /**
- * Determines whether a character is ASCII, meaning that its code point is less than 128.
- */
- public static final CharMatcher ASCII = ascii();
-
- /**
- * Determines whether a character is a digit according to
- * Unicode .
- * If you only care to match ASCII digits, you can use {@code inRange('0', '9')}.
- */
- public static final CharMatcher DIGIT = digit();
-
- /**
- * Determines whether a character is a digit according to {@linkplain Character#isDigit(char)
- * Java's definition}. If you only care to match ASCII digits, you can use {@code
- * inRange('0', '9')}.
- */
- public static final CharMatcher JAVA_DIGIT = javaDigit();
-
- /**
- * Determines whether a character is a letter according to {@linkplain Character#isLetter(char)
- * Java's definition}. If you only care to match letters of the Latin alphabet, you can use {@code
- * inRange('a', 'z').or(inRange('A', 'Z'))}.
- */
- public static final CharMatcher JAVA_LETTER = javaLetter();
-
- /**
- * Determines whether a character is a letter or digit according to {@linkplain
- * Character#isLetterOrDigit(char) Java's definition}.
- */
- public static final CharMatcher JAVA_LETTER_OR_DIGIT = javaLetterOrDigit();
-
- /**
- * Determines whether a character is upper case according to {@linkplain
- * Character#isUpperCase(char) Java's definition}.
- */
- public static final CharMatcher JAVA_UPPER_CASE = javaUpperCase();
-
- /**
- * Determines whether a character is lower case according to {@linkplain
- * Character#isLowerCase(char) Java's definition}.
- */
- public static final CharMatcher JAVA_LOWER_CASE = javaLowerCase();
-
- /**
- * Determines whether a character is an ISO control character as specified by {@link
- * Character#isISOControl(char)}.
- */
- public static final CharMatcher JAVA_ISO_CONTROL = javaIsoControl();
-
- /**
- * Determines whether a character is invisible; that is, if its Unicode category is any of
- * SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, SURROGATE, and
- * PRIVATE_USE according to ICU4J.
- */
- public static final CharMatcher INVISIBLE = invisible();
-
- /**
- * Determines whether a character is single-width (not double-width). When in doubt, this matcher
- * errs on the side of returning {@code false} (that is, it tends to assume a character is
- * double-width).
- *
- *
Note: as the reference file evolves, we will modify this constant to keep it up to
- * date.
- */
- public static final CharMatcher SINGLE_WIDTH = singleWidth();
-
- /** Matches any character. */
- public static final CharMatcher ANY = any();
-
- /** Matches no characters. */
- public static final CharMatcher NONE = none();
-
- // Static factories
-
- /**
- * Returns a {@code char} matcher that matches only one specified character.
- */
- public static CharMatcher is(final char match) {
- return new Is(match);
- }
-
- /**
- * Returns a {@code char} matcher that matches any character except the one specified.
- *
- *
To negate another {@code CharMatcher}, use {@link #negate()}.
- */
- public static CharMatcher isNot(final char match) {
- return new IsNot(match);
- }
-
- /**
- * Returns a {@code char} matcher that matches any character present in the given character
- * sequence.
- */
- public static CharMatcher anyOf(final CharSequence sequence) {
- switch (sequence.length()) {
- case 0:
- return none();
- case 1:
- return is(sequence.charAt(0));
- case 2:
- return isEither(sequence.charAt(0), sequence.charAt(1));
- default:
- // TODO(lowasser): is it potentially worth just going ahead and building a precomputed
- // matcher?
- return new AnyOf(sequence);
- }
- }
-
- /**
- * Returns a {@code char} matcher that matches any character not present in the given character
- * sequence.
- */
- public static CharMatcher noneOf(CharSequence sequence) {
- return anyOf(sequence).negate();
- }
-
- /**
- * Returns a {@code char} matcher that matches any character in a given range (both endpoints are
- * inclusive). For example, to match any lowercase letter of the English alphabet, use {@code
- * CharMatcher.inRange('a', 'z')}.
- *
- * @throws IllegalArgumentException if {@code endInclusive < startInclusive}
- */
- public static CharMatcher inRange(final char startInclusive, final char endInclusive) {
- return new InRange(startInclusive, endInclusive);
- }
-
- /**
- * Returns a matcher with identical behavior to the given {@link Character}-based predicate, but
- * which operates on primitive {@code char} instances instead.
- */
- public static CharMatcher forPredicate(final Predicate predicate) {
- return predicate instanceof CharMatcher ? (CharMatcher) predicate : new ForPredicate(predicate);
- }
-
- // Constructors
-
- /**
- * Constructor for use by subclasses. When subclassing, you may want to override
- * {@code toString()} to provide a useful description.
- */
- protected CharMatcher() {}
-
- // Abstract methods
-
- /** Determines a true or false value for the given character. */
- public abstract boolean matches(char c);
-
- // Non-static factories
-
- /**
- * Returns a matcher that matches any character not matched by this matcher.
- */
- public CharMatcher negate() {
- return new Negated(this);
- }
-
- /**
- * Returns a matcher that matches any character matched by both this matcher and {@code other}.
- */
- public CharMatcher and(CharMatcher other) {
- return new And(this, other);
- }
-
- /**
- * Returns a matcher that matches any character matched by either this matcher or {@code other}.
- */
- public CharMatcher or(CharMatcher other) {
- return new Or(this, other);
- }
-
- /**
- * Returns a {@code char} matcher functionally equivalent to this one, but which may be faster to
- * query than the original; your mileage may vary. Precomputation takes time and is likely to be
- * worthwhile only if the precomputed matcher is queried many thousands of times.
- *
- *
This method has no effect (returns {@code this}) when called in GWT: it's unclear whether a
- * precomputed matcher is faster, but it certainly consumes more memory, which doesn't seem like a
- * worthwhile tradeoff in a browser.
- */
- public CharMatcher precomputed() {
- return Platform.precomputeCharMatcher(this);
- }
-
- private static final int DISTINCT_CHARS = Character.MAX_VALUE - Character.MIN_VALUE + 1;
-
- /**
- * This is the actual implementation of {@link #precomputed}, but we bounce calls through a
- * method on {@link Platform} so that we can have different behavior in GWT.
- *
- *
This implementation tries to be smart in a number of ways. It recognizes cases where
- * the negation is cheaper to precompute than the matcher itself; it tries to build small
- * hash tables for matchers that only match a few characters, and so on. In the worst-case
- * scenario, it constructs an eight-kilobyte bit array and queries that.
- * In many situations this produces a matcher which is faster to query than the original.
- */
- @GwtIncompatible("java.util.BitSet")
- CharMatcher precomputedInternal() {
- final BitSet table = new BitSet();
- setBits(table);
- int totalCharacters = table.cardinality();
- if (totalCharacters * 2 <= DISTINCT_CHARS) {
- return precomputedPositive(totalCharacters, table, toString());
- } else {
- // TODO(lowasser): is it worth it to worry about the last character of large matchers?
- table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1);
- int negatedCharacters = DISTINCT_CHARS - totalCharacters;
- String suffix = ".negate()";
- final String description = toString();
- String negatedDescription =
- description.endsWith(suffix)
- ? description.substring(0, description.length() - suffix.length())
- : description + suffix;
- return new NegatedFastMatcher(
- precomputedPositive(negatedCharacters, table, negatedDescription)) {
- @Override
- public String toString() {
- return description;
- }
- };
- }
- }
-
- /**
- * Helper method for {@link #precomputedInternal} that doesn't test if the negation is cheaper.
- */
- @GwtIncompatible("java.util.BitSet")
- private static CharMatcher precomputedPositive(
- int totalCharacters, BitSet table, String description) {
- switch (totalCharacters) {
- case 0:
- return none();
- case 1:
- return is((char) table.nextSetBit(0));
- case 2:
- char c1 = (char) table.nextSetBit(0);
- char c2 = (char) table.nextSetBit(c1 + 1);
- return isEither(c1, c2);
- default:
- return isSmall(totalCharacters, table.length())
- ? SmallCharMatcher.from(table, description)
- : new BitSetMatcher(table, description);
- }
- }
-
- @GwtIncompatible("SmallCharMatcher")
- private static boolean isSmall(int totalCharacters, int tableLength) {
- return totalCharacters <= SmallCharMatcher.MAX_SIZE
- && tableLength > (totalCharacters * 4 * Character.SIZE);
- // err on the side of BitSetMatcher
- }
-
- /**
- * Sets bits in {@code table} matched by this matcher.
- */
- @GwtIncompatible("java.util.BitSet")
- void setBits(BitSet table) {
- for (int c = Character.MAX_VALUE; c >= Character.MIN_VALUE; c--) {
- if (matches((char) c)) {
- table.set(c);
- }
- }
- }
-
- // Text processing routines
-
- /**
- * Returns {@code true} if a character sequence contains at least one matching character.
- * Equivalent to {@code !matchesNoneOf(sequence)}.
- *
- *
The default implementation iterates over the sequence, invoking {@link #matches} for each
- * character, until this returns {@code true} or the end is reached.
- *
- * @param sequence the character sequence to examine, possibly empty
- * @return {@code true} if this matcher matches at least one character in the sequence
- * @since 8.0
- */
- public boolean matchesAnyOf(CharSequence sequence) {
- return !matchesNoneOf(sequence);
- }
-
- /**
- * Returns {@code true} if a character sequence contains only matching characters.
- *
- *
The default implementation iterates over the sequence, invoking {@link #matches} for each
- * character, until this returns {@code false} or the end is reached.
- *
- * @param sequence the character sequence to examine, possibly empty
- * @return {@code true} if this matcher matches every character in the sequence, including when
- * the sequence is empty
- */
- public boolean matchesAllOf(CharSequence sequence) {
- for (int i = sequence.length() - 1; i >= 0; i--) {
- if (!matches(sequence.charAt(i))) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Returns {@code true} if a character sequence contains no matching characters. Equivalent to
- * {@code !matchesAnyOf(sequence)}.
- *
- *
The default implementation iterates over the sequence, invoking {@link #matches} for each
- * character, until this returns {@code false} or the end is reached.
- *
- * @param sequence the character sequence to examine, possibly empty
- * @return {@code true} if this matcher matches every character in the sequence, including when
- * the sequence is empty
- */
- public boolean matchesNoneOf(CharSequence sequence) {
- return indexIn(sequence) == -1;
- }
-
- /**
- * Returns the index of the first matching character in a character sequence, or {@code -1} if no
- * matching character is present.
- *
- *
The default implementation iterates over the sequence in forward order calling {@link
- * #matches} for each character.
- *
- * @param sequence the character sequence to examine from the beginning
- * @return an index, or {@code -1} if no character matches
- */
- public int indexIn(CharSequence sequence) {
- return indexIn(sequence, 0);
- }
-
- /**
- * Returns the index of the first matching character in a character sequence, starting from a
- * given position, or {@code -1} if no character matches after that position.
- *
- *
The default implementation iterates over the sequence in forward order, beginning at {@code
- * start}, calling {@link #matches} for each character.
- *
- * @param sequence the character sequence to examine
- * @param start the first index to examine; must be nonnegative and no greater than {@code
- * sequence.length()}
- * @return the index of the first matching character, guaranteed to be no less than {@code start},
- * or {@code -1} if no character matches
- * @throws IndexOutOfBoundsException if start is negative or greater than {@code
- * sequence.length()}
- */
- public int indexIn(CharSequence sequence, int start) {
- int length = sequence.length();
- checkPositionIndex(start, length);
- for (int i = start; i < length; i++) {
- if (matches(sequence.charAt(i))) {
- return i;
- }
- }
- return -1;
- }
-
- /**
- * Returns the index of the last matching character in a character sequence, or {@code -1} if no
- * matching character is present.
- *
- *
The default implementation iterates over the sequence in reverse order calling {@link
- * #matches} for each character.
- *
- * @param sequence the character sequence to examine from the end
- * @return an index, or {@code -1} if no character matches
- */
- public int lastIndexIn(CharSequence sequence) {
- for (int i = sequence.length() - 1; i >= 0; i--) {
- if (matches(sequence.charAt(i))) {
- return i;
- }
- }
- return -1;
- }
-
- /**
- * Returns the number of matching characters found in a character sequence.
- */
- public int countIn(CharSequence sequence) {
- int count = 0;
- for (int i = 0; i < sequence.length(); i++) {
- if (matches(sequence.charAt(i))) {
- count++;
- }
- }
- return count;
- }
-
- /**
- * Returns a string containing all non-matching characters of a character sequence, in order. For
- * example:
{@code
- *
- * CharMatcher.is('a').removeFrom("bazaar")}
- *
- * ... returns {@code "bzr"}.
- */
- @CheckReturnValue
- public String removeFrom(CharSequence sequence) {
- String string = sequence.toString();
- int pos = indexIn(string);
- if (pos == -1) {
- return string;
- }
-
- char[] chars = string.toCharArray();
- int spread = 1;
-
- // This unusual loop comes from extensive benchmarking
- OUT:
- while (true) {
- pos++;
- while (true) {
- if (pos == chars.length) {
- break OUT;
- }
- if (matches(chars[pos])) {
- break;
- }
- chars[pos - spread] = chars[pos];
- pos++;
- }
- spread++;
- }
- return new String(chars, 0, pos - spread);
- }
-
- /**
- * Returns a string containing all matching characters of a character sequence, in order. For
- * example: {@code
- *
- * CharMatcher.is('a').retainFrom("bazaar")}
- *
- * ... returns {@code "aaa"}.
- */
- @CheckReturnValue
- public String retainFrom(CharSequence sequence) {
- return negate().removeFrom(sequence);
- }
-
- /**
- * Returns a string copy of the input character sequence, with each character that matches this
- * matcher replaced by a given replacement character. For example: {@code
- *
- * CharMatcher.is('a').replaceFrom("radar", 'o')}
- *
- * ... returns {@code "rodor"}.
- *
- * The default implementation uses {@link #indexIn(CharSequence)} to find the first matching
- * character, then iterates the remainder of the sequence calling {@link #matches(char)} for each
- * character.
- *
- * @param sequence the character sequence to replace matching characters in
- * @param replacement the character to append to the result string in place of each matching
- * character in {@code sequence}
- * @return the new string
- */
- @CheckReturnValue
- public String replaceFrom(CharSequence sequence, char replacement) {
- String string = sequence.toString();
- int pos = indexIn(string);
- if (pos == -1) {
- return string;
- }
- char[] chars = string.toCharArray();
- chars[pos] = replacement;
- for (int i = pos + 1; i < chars.length; i++) {
- if (matches(chars[i])) {
- chars[i] = replacement;
- }
- }
- return new String(chars);
- }
-
- /**
- * Returns a string copy of the input character sequence, with each character that matches this
- * matcher replaced by a given replacement sequence. For example:
{@code
- *
- * CharMatcher.is('a').replaceFrom("yaha", "oo")}
- *
- * ... returns {@code "yoohoo"}.
- *
- * Note: If the replacement is a fixed string with only one character, you are better
- * off calling {@link #replaceFrom(CharSequence, char)} directly.
- *
- * @param sequence the character sequence to replace matching characters in
- * @param replacement the characters to append to the result string in place of each matching
- * character in {@code sequence}
- * @return the new string
- */
- @CheckReturnValue
- public String replaceFrom(CharSequence sequence, CharSequence replacement) {
- int replacementLen = replacement.length();
- if (replacementLen == 0) {
- return removeFrom(sequence);
- }
- if (replacementLen == 1) {
- return replaceFrom(sequence, replacement.charAt(0));
- }
-
- String string = sequence.toString();
- int pos = indexIn(string);
- if (pos == -1) {
- return string;
- }
-
- int len = string.length();
- StringBuilder buf = new StringBuilder((len * 3 / 2) + 16);
-
- int oldpos = 0;
- do {
- buf.append(string, oldpos, pos);
- buf.append(replacement);
- oldpos = pos + 1;
- pos = indexIn(string, oldpos);
- } while (pos != -1);
-
- buf.append(string, oldpos, len);
- return buf.toString();
- }
-
- /**
- * Returns a substring of the input character sequence that omits all characters this matcher
- * matches from the beginning and from the end of the string. For example:
{@code
- *
- * CharMatcher.anyOf("ab").trimFrom("abacatbab")}
- *
- * ... returns {@code "cat"}.
- *
- * Note that:
{@code
- *
- * CharMatcher.inRange('\0', ' ').trimFrom(str)}
- *
- * ... is equivalent to {@link String#trim()}.
- */
- @CheckReturnValue
- public String trimFrom(CharSequence sequence) {
- int len = sequence.length();
- int first;
- int last;
-
- for (first = 0; first < len; first++) {
- if (!matches(sequence.charAt(first))) {
- break;
- }
- }
- for (last = len - 1; last > first; last--) {
- if (!matches(sequence.charAt(last))) {
- break;
- }
- }
-
- return sequence.subSequence(first, last + 1).toString();
- }
-
- /**
- * Returns a substring of the input character sequence that omits all characters this matcher
- * matches from the beginning of the string. For example: {@code
- *
- * CharMatcher.anyOf("ab").trimLeadingFrom("abacatbab")}
- *
- * ... returns {@code "catbab"}.
- */
- @CheckReturnValue
- public String trimLeadingFrom(CharSequence sequence) {
- int len = sequence.length();
- for (int first = 0; first < len; first++) {
- if (!matches(sequence.charAt(first))) {
- return sequence.subSequence(first, len).toString();
- }
- }
- return "";
- }
-
- /**
- * Returns a substring of the input character sequence that omits all characters this matcher
- * matches from the end of the string. For example: {@code
- *
- * CharMatcher.anyOf("ab").trimTrailingFrom("abacatbab")}
- *
- * ... returns {@code "abacat"}.
- */
- @CheckReturnValue
- public String trimTrailingFrom(CharSequence sequence) {
- int len = sequence.length();
- for (int last = len - 1; last >= 0; last--) {
- if (!matches(sequence.charAt(last))) {
- return sequence.subSequence(0, last + 1).toString();
- }
- }
- return "";
- }
-
- /**
- * Returns a string copy of the input character sequence, with each group of consecutive
- * characters that match this matcher replaced by a single replacement character. For example:
- * {@code
- *
- * CharMatcher.anyOf("eko").collapseFrom("bookkeeper", '-')}
- *
- * ... returns {@code "b-p-r"}.
- *
- * The default implementation uses {@link #indexIn(CharSequence)} to find the first matching
- * character, then iterates the remainder of the sequence calling {@link #matches(char)} for each
- * character.
- *
- * @param sequence the character sequence to replace matching groups of characters in
- * @param replacement the character to append to the result string in place of each group of
- * matching characters in {@code sequence}
- * @return the new string
- */
- @CheckReturnValue
- public String collapseFrom(CharSequence sequence, char replacement) {
- // This implementation avoids unnecessary allocation.
- int len = sequence.length();
- for (int i = 0; i < len; i++) {
- char c = sequence.charAt(i);
- if (matches(c)) {
- if (c == replacement && (i == len - 1 || !matches(sequence.charAt(i + 1)))) {
- // a no-op replacement
- i++;
- } else {
- StringBuilder builder =
- new StringBuilder(len).append(sequence.subSequence(0, i)).append(replacement);
- return finishCollapseFrom(sequence, i + 1, len, replacement, builder, true);
- }
- }
- }
- // no replacement needed
- return sequence.toString();
- }
-
- /**
- * Collapses groups of matching characters exactly as {@link #collapseFrom} does, except that
- * groups of matching characters at the start or end of the sequence are removed without
- * replacement.
- */
- @CheckReturnValue
- public String trimAndCollapseFrom(CharSequence sequence, char replacement) {
- // This implementation avoids unnecessary allocation.
- int len = sequence.length();
- int first = 0;
- int last = len - 1;
-
- while (first < len && matches(sequence.charAt(first))) {
- first++;
- }
-
- while (last > first && matches(sequence.charAt(last))) {
- last--;
- }
-
- return (first == 0 && last == len - 1)
- ? collapseFrom(sequence, replacement)
- : finishCollapseFrom(
- sequence, first, last + 1, replacement, new StringBuilder(last + 1 - first), false);
- }
-
- private String finishCollapseFrom(
- CharSequence sequence,
- int start,
- int end,
- char replacement,
- StringBuilder builder,
- boolean inMatchingGroup) {
- for (int i = start; i < end; i++) {
- char c = sequence.charAt(i);
- if (matches(c)) {
- if (!inMatchingGroup) {
- builder.append(replacement);
- inMatchingGroup = true;
- }
- } else {
- builder.append(c);
- inMatchingGroup = false;
- }
- }
- return builder.toString();
- }
-
- /**
- * @deprecated Provided only to satisfy the {@link Predicate} interface; use {@link #matches}
- * instead.
- */
- @Deprecated
- @Override
- public boolean apply(Character character) {
- return matches(character);
- }
-
- /**
- * Returns a string representation of this {@code CharMatcher}, such as
- * {@code CharMatcher.or(WHITESPACE, JAVA_DIGIT)}.
- */
- @Override
- public String toString() {
- return super.toString();
- }
-
- /**
- * Returns the Java Unicode escape sequence for the given character, in the form "\u12AB" where
- * "12AB" is the four hexadecimal digits representing the 16 bits of the UTF-16 character.
- */
- private static String showCharacter(char c) {
- String hex = "0123456789ABCDEF";
- char[] tmp = {'\\', 'u', '\0', '\0', '\0', '\0'};
- for (int i = 0; i < 4; i++) {
- tmp[5 - i] = hex.charAt(c & 0xF);
- c = (char) (c >> 4);
- }
- return String.copyValueOf(tmp);
- }
-
- // Fast matchers
-
- /** A matcher for which precomputation will not yield any significant benefit. */
- abstract static class FastMatcher extends CharMatcher {
-
- @Override
- public final CharMatcher precomputed() {
- return this;
- }
-
- @Override
- public CharMatcher negate() {
- return new NegatedFastMatcher(this);
- }
- }
-
- /** {@link FastMatcher} which overrides {@code toString()} with a custom name. */
- abstract static class NamedFastMatcher extends FastMatcher {
-
- private final String description;
-
- NamedFastMatcher(String description) {
- this.description = checkNotNull(description);
- }
-
- @Override
- public final String toString() {
- return description;
- }
- }
-
- /** Negation of a {@link FastMatcher}. */
- static class NegatedFastMatcher extends Negated {
-
- NegatedFastMatcher(CharMatcher original) {
- super(original);
- }
-
- @Override
- public final CharMatcher precomputed() {
- return this;
- }
- }
-
- /** Fast matcher using a {@link BitSet} table of matching characters. */
- @GwtIncompatible("java.util.BitSet")
- private static final class BitSetMatcher extends NamedFastMatcher {
-
- private final BitSet table;
-
- private BitSetMatcher(BitSet table, String description) {
- super(description);
- if (table.length() + Long.SIZE < table.size()) {
- table = (BitSet) table.clone();
- // If only we could actually call BitSet.trimToSize() ourselves...
- }
- this.table = table;
- }
-
- @Override
- public boolean matches(char c) {
- return table.get(c);
- }
-
- @Override
- void setBits(BitSet bitSet) {
- bitSet.or(table);
- }
- }
-
- // Static constant implementation classes
-
- /** Implementation of {@link #any()}. */
- private static final class Any extends NamedFastMatcher {
-
- static final Any INSTANCE = new Any();
-
- private Any() {
- super("CharMatcher.any()");
- }
-
- @Override
- public boolean matches(char c) {
- return true;
- }
-
- @Override
- public int indexIn(CharSequence sequence) {
- return (sequence.length() == 0) ? -1 : 0;
- }
-
- @Override
- public int indexIn(CharSequence sequence, int start) {
- int length = sequence.length();
- checkPositionIndex(start, length);
- return (start == length) ? -1 : start;
- }
-
- @Override
- public int lastIndexIn(CharSequence sequence) {
- return sequence.length() - 1;
- }
-
- @Override
- public boolean matchesAllOf(CharSequence sequence) {
- checkNotNull(sequence);
- return true;
- }
-
- @Override
- public boolean matchesNoneOf(CharSequence sequence) {
- return sequence.length() == 0;
- }
-
- @Override
- public String removeFrom(CharSequence sequence) {
- checkNotNull(sequence);
- return "";
- }
-
- @Override
- public String replaceFrom(CharSequence sequence, char replacement) {
- char[] array = new char[sequence.length()];
- Arrays.fill(array, replacement);
- return new String(array);
- }
-
- @Override
- public String replaceFrom(CharSequence sequence, CharSequence replacement) {
- StringBuilder result = new StringBuilder(sequence.length() * replacement.length());
- for (int i = 0; i < sequence.length(); i++) {
- result.append(replacement);
- }
- return result.toString();
- }
-
- @Override
- public String collapseFrom(CharSequence sequence, char replacement) {
- return (sequence.length() == 0) ? "" : String.valueOf(replacement);
- }
-
- @Override
- public String trimFrom(CharSequence sequence) {
- checkNotNull(sequence);
- return "";
- }
-
- @Override
- public int countIn(CharSequence sequence) {
- return sequence.length();
- }
-
- @Override
- public CharMatcher and(CharMatcher other) {
- return checkNotNull(other);
- }
-
- @Override
- public CharMatcher or(CharMatcher other) {
- checkNotNull(other);
- return this;
- }
-
- @Override
- public CharMatcher negate() {
- return none();
- }
- }
-
- /** Implementation of {@link #none()}. */
- private static final class None extends NamedFastMatcher {
-
- static final None INSTANCE = new None();
-
- private None() {
- super("CharMatcher.none()");
- }
-
- @Override
- public boolean matches(char c) {
- return false;
- }
-
- @Override
- public int indexIn(CharSequence sequence) {
- checkNotNull(sequence);
- return -1;
- }
-
- @Override
- public int indexIn(CharSequence sequence, int start) {
- int length = sequence.length();
- checkPositionIndex(start, length);
- return -1;
- }
-
- @Override
- public int lastIndexIn(CharSequence sequence) {
- checkNotNull(sequence);
- return -1;
- }
-
- @Override
- public boolean matchesAllOf(CharSequence sequence) {
- return sequence.length() == 0;
- }
-
- @Override
- public boolean matchesNoneOf(CharSequence sequence) {
- checkNotNull(sequence);
- return true;
- }
-
- @Override
- public String removeFrom(CharSequence sequence) {
- return sequence.toString();
- }
-
- @Override
- public String replaceFrom(CharSequence sequence, char replacement) {
- return sequence.toString();
- }
-
- @Override
- public String replaceFrom(CharSequence sequence, CharSequence replacement) {
- checkNotNull(replacement);
- return sequence.toString();
- }
-
- @Override
- public String collapseFrom(CharSequence sequence, char replacement) {
- return sequence.toString();
- }
-
- @Override
- public String trimFrom(CharSequence sequence) {
- return sequence.toString();
- }
-
- @Override
- public String trimLeadingFrom(CharSequence sequence) {
- return sequence.toString();
- }
-
- @Override
- public String trimTrailingFrom(CharSequence sequence) {
- return sequence.toString();
- }
-
- @Override
- public int countIn(CharSequence sequence) {
- checkNotNull(sequence);
- return 0;
- }
-
- @Override
- public CharMatcher and(CharMatcher other) {
- checkNotNull(other);
- return this;
- }
-
- @Override
- public CharMatcher or(CharMatcher other) {
- return checkNotNull(other);
- }
-
- @Override
- public CharMatcher negate() {
- return any();
- }
- }
-
- /** Implementation of {@link #whitespace()}. */
- @VisibleForTesting
- static final class Whitespace extends NamedFastMatcher {
-
- static final String TABLE =
- "\u2002\u3000\r\u0085\u200A\u2005\u2000\u3000"
- + "\u2029\u000B\u3000\u2008\u2003\u205F\u3000\u1680"
- + "\u0009\u0020\u2006\u2001\u202F\u00A0\u000C\u2009"
- + "\u3000\u2004\u3000\u3000\u2028\n\u2007\u3000";
- static final int MULTIPLIER = 1682554634;
- static final int SHIFT = Integer.numberOfLeadingZeros(TABLE.length() - 1);
-
- static final Whitespace INSTANCE = new Whitespace();
-
- Whitespace() {
- super("CharMatcher.whitespace()");
- }
-
- @Override
- public boolean matches(char c) {
- return TABLE.charAt((MULTIPLIER * c) >>> SHIFT) == c;
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- for (int i = 0; i < TABLE.length(); i++) {
- table.set(TABLE.charAt(i));
- }
- }
- }
-
- /** Implementation of {@link #breakingWhitespace()}. */
- private static final class BreakingWhitespace extends CharMatcher {
-
- static final CharMatcher INSTANCE = new BreakingWhitespace();
-
- @Override
- public boolean matches(char c) {
- switch (c) {
- case '\t':
- case '\n':
- case '\013':
- case '\f':
- case '\r':
- case ' ':
- case '\u0085':
- case '\u1680':
- case '\u2028':
- case '\u2029':
- case '\u205f':
- case '\u3000':
- return true;
- case '\u2007':
- return false;
- default:
- return c >= '\u2000' && c <= '\u200a';
- }
- }
-
- @Override
- public String toString() {
- return "CharMatcher.breakingWhitespace()";
- }
- }
-
- /** Implementation of {@link #ascii()}. */
- private static final class Ascii extends NamedFastMatcher {
-
- static final Ascii INSTANCE = new Ascii();
-
- Ascii() {
- super("CharMatcher.ascii()");
- }
-
- @Override
- public boolean matches(char c) {
- return c <= '\u007f';
- }
- }
-
- /** Implementation that matches characters that fall within multiple ranges. */
- private static class RangesMatcher extends CharMatcher {
-
- private final String description;
- private final char[] rangeStarts;
- private final char[] rangeEnds;
-
- RangesMatcher(String description, char[] rangeStarts, char[] rangeEnds) {
- this.description = description;
- this.rangeStarts = rangeStarts;
- this.rangeEnds = rangeEnds;
- checkArgument(rangeStarts.length == rangeEnds.length);
- for (int i = 0; i < rangeStarts.length; i++) {
- checkArgument(rangeStarts[i] <= rangeEnds[i]);
- if (i + 1 < rangeStarts.length) {
- checkArgument(rangeEnds[i] < rangeStarts[i + 1]);
- }
- }
- }
-
- @Override
- public boolean matches(char c) {
- int index = Arrays.binarySearch(rangeStarts, c);
- if (index >= 0) {
- return true;
- } else {
- index = ~index - 1;
- return index >= 0 && c <= rangeEnds[index];
- }
- }
-
- @Override
- public String toString() {
- return description;
- }
- }
-
- /** Implementation of {@link #digit()}. */
- private static final class Digit extends RangesMatcher {
-
- // Must be in ascending order.
- private static final String ZEROES =
- "0\u0660\u06f0\u07c0\u0966\u09e6\u0a66\u0ae6\u0b66"
- + "\u0be6\u0c66\u0ce6\u0d66\u0e50\u0ed0\u0f20\u1040\u1090\u17e0\u1810"
- + "\u1946\u19d0\u1b50\u1bb0\u1c40\u1c50\ua620\ua8d0\ua900\uaa50\uff10";
-
- private static char[] zeroes() {
- return ZEROES.toCharArray();
- }
-
- private static char[] nines() {
- char[] nines = new char[ZEROES.length()];
- for (int i = 0; i < ZEROES.length(); i++) {
- nines[i] = (char) (ZEROES.charAt(i) + 9);
- }
- return nines;
- }
-
- static final Digit INSTANCE = new Digit();
-
- private Digit() {
- super("CharMatcher.digit()", zeroes(), nines());
- }
- }
-
- /** Implementation of {@link #javaDigit()}. */
- private static final class JavaDigit extends CharMatcher {
-
- static final JavaDigit INSTANCE = new JavaDigit();
-
- @Override
- public boolean matches(char c) {
- return Character.isDigit(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.javaDigit()";
- }
- }
-
- /** Implementation of {@link #javaLetter()}. */
- private static final class JavaLetter extends CharMatcher {
-
- static final JavaLetter INSTANCE = new JavaLetter();
-
- @Override
- public boolean matches(char c) {
- return Character.isLetter(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.javaLetter()";
- }
- }
-
- /** Implementation of {@link #javaLetterOrDigit()}. */
- private static final class JavaLetterOrDigit extends CharMatcher {
-
- static final JavaLetterOrDigit INSTANCE = new JavaLetterOrDigit();
-
- @Override
- public boolean matches(char c) {
- return Character.isLetterOrDigit(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.javaLetterOrDigit()";
- }
- }
-
- /** Implementation of {@link #javaUpperCase()}. */
- private static final class JavaUpperCase extends CharMatcher {
-
- static final JavaUpperCase INSTANCE = new JavaUpperCase();
-
- @Override
- public boolean matches(char c) {
- return Character.isUpperCase(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.javaUpperCase()";
- }
- }
-
- /** Implementation of {@link #javaLowerCase()}. */
- private static final class JavaLowerCase extends CharMatcher {
-
- static final JavaLowerCase INSTANCE = new JavaLowerCase();
-
- @Override
- public boolean matches(char c) {
- return Character.isLowerCase(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.javaLowerCase()";
- }
- }
-
- /** Implementation of {@link #javaIsoControl()}. */
- private static final class JavaIsoControl extends NamedFastMatcher {
-
- static final JavaIsoControl INSTANCE = new JavaIsoControl();
-
- private JavaIsoControl() {
- super("CharMatcher.javaIsoControl()");
- }
-
- @Override
- public boolean matches(char c) {
- return c <= '\u001f' || (c >= '\u007f' && c <= '\u009f');
- }
- }
-
- /** Implementation of {@link #invisible()}. */
- private static final class Invisible extends RangesMatcher {
-
- private static final String RANGE_STARTS =
- "\u0000\u007f\u00ad\u0600\u061c\u06dd\u070f\u1680\u180e\u2000\u2028\u205f\u2066\u2067"
- + "\u2068\u2069\u206a\u3000\ud800\ufeff\ufff9\ufffa";
- private static final String RANGE_ENDS =
- "\u0020\u00a0\u00ad\u0604\u061c\u06dd\u070f\u1680\u180e\u200f\u202f\u2064\u2066\u2067"
- + "\u2068\u2069\u206f\u3000\uf8ff\ufeff\ufff9\ufffb";
-
- static final Invisible INSTANCE = new Invisible();
-
- private Invisible() {
- super(
- "CharMatcher.invisible()",
- RANGE_STARTS.toCharArray(),
- RANGE_ENDS.toCharArray());
- }
- }
-
- /** Implementation of {@link #singleWidth()}. */
- private static final class SingleWidth extends RangesMatcher {
-
- static final SingleWidth INSTANCE = new SingleWidth();
-
- private SingleWidth() {
- super(
- "CharMatcher.singleWidth()",
- "\u0000\u05be\u05d0\u05f3\u0600\u0750\u0e00\u1e00\u2100\ufb50\ufe70\uff61".toCharArray(),
- "\u04f9\u05be\u05ea\u05f4\u06ff\u077f\u0e7f\u20af\u213a\ufdff\ufeff\uffdc".toCharArray());
- }
- }
-
- // Non-static factory implementation classes
-
- /** Implementation of {@link #negate()}. */
- private static class Negated extends CharMatcher {
-
- final CharMatcher original;
-
- Negated(CharMatcher original) {
- this.original = checkNotNull(original);
- }
-
- @Override
- public boolean matches(char c) {
- return !original.matches(c);
- }
-
- @Override
- public boolean matchesAllOf(CharSequence sequence) {
- return original.matchesNoneOf(sequence);
- }
-
- @Override
- public boolean matchesNoneOf(CharSequence sequence) {
- return original.matchesAllOf(sequence);
- }
-
- @Override
- public int countIn(CharSequence sequence) {
- return sequence.length() - original.countIn(sequence);
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- BitSet tmp = new BitSet();
- original.setBits(tmp);
- tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1);
- table.or(tmp);
- }
-
- @Override
- public CharMatcher negate() {
- return original;
- }
-
- @Override
- public String toString() {
- return original + ".negate()";
- }
- }
-
- /** Implementation of {@link #and(CharMatcher)}. */
- private static final class And extends CharMatcher {
-
- final CharMatcher first;
- final CharMatcher second;
-
- And(CharMatcher a, CharMatcher b) {
- first = checkNotNull(a);
- second = checkNotNull(b);
- }
-
- @Override
- public boolean matches(char c) {
- return first.matches(c) && second.matches(c);
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- BitSet tmp1 = new BitSet();
- first.setBits(tmp1);
- BitSet tmp2 = new BitSet();
- second.setBits(tmp2);
- tmp1.and(tmp2);
- table.or(tmp1);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.and(" + first + ", " + second + ")";
- }
- }
-
- /** Implementation of {@link #or(CharMatcher)}. */
- private static final class Or extends CharMatcher {
-
- final CharMatcher first;
- final CharMatcher second;
-
- Or(CharMatcher a, CharMatcher b) {
- first = checkNotNull(a);
- second = checkNotNull(b);
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- first.setBits(table);
- second.setBits(table);
- }
-
- @Override
- public boolean matches(char c) {
- return first.matches(c) || second.matches(c);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.or(" + first + ", " + second + ")";
- }
- }
-
- // Static factory implementations
-
- /** Implementation of {@link #is(char)}. */
- private static final class Is extends FastMatcher {
-
- private final char match;
-
- Is(char match) {
- this.match = match;
- }
-
- @Override
- public boolean matches(char c) {
- return c == match;
- }
-
- @Override
- public String replaceFrom(CharSequence sequence, char replacement) {
- return sequence.toString().replace(match, replacement);
- }
-
- @Override
- public CharMatcher and(CharMatcher other) {
- return other.matches(match) ? this : none();
- }
-
- @Override
- public CharMatcher or(CharMatcher other) {
- return other.matches(match) ? other : super.or(other);
- }
-
- @Override
- public CharMatcher negate() {
- return isNot(match);
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- table.set(match);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.is('" + showCharacter(match) + "')";
- }
- }
-
- /** Implementation of {@link #isNot(char)}. */
- private static final class IsNot extends FastMatcher {
-
- private final char match;
-
- IsNot(char match) {
- this.match = match;
- }
-
- @Override
- public boolean matches(char c) {
- return c != match;
- }
-
- @Override
- public CharMatcher and(CharMatcher other) {
- return other.matches(match) ? super.and(other) : other;
- }
-
- @Override
- public CharMatcher or(CharMatcher other) {
- return other.matches(match) ? any() : this;
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- table.set(0, match);
- table.set(match + 1, Character.MAX_VALUE + 1);
- }
-
- @Override
- public CharMatcher negate() {
- return is(match);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.isNot('" + showCharacter(match) + "')";
- }
- }
-
- private static CharMatcher.IsEither isEither(char c1, char c2) {
- return new CharMatcher.IsEither(c1, c2);
- }
-
- /** Implementation of {@link #anyOf(CharSequence)} for exactly two characters. */
- private static final class IsEither extends FastMatcher {
-
- private final char match1;
- private final char match2;
-
- IsEither(char match1, char match2) {
- this.match1 = match1;
- this.match2 = match2;
- }
-
- @Override
- public boolean matches(char c) {
- return c == match1 || c == match2;
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- table.set(match1);
- table.set(match2);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.anyOf(\"" + showCharacter(match1) + showCharacter(match2) + "\")";
- }
- }
-
- /** Implementation of {@link #anyOf(CharSequence)} for three or more characters. */
- private static final class AnyOf extends CharMatcher {
-
- private final char[] chars;
-
- public AnyOf(CharSequence chars) {
- this.chars = chars.toString().toCharArray();
- Arrays.sort(this.chars);
- }
-
- @Override
- public boolean matches(char c) {
- return Arrays.binarySearch(chars, c) >= 0;
- }
-
- @Override
- @GwtIncompatible("java.util.BitSet")
- void setBits(BitSet table) {
- for (char c : chars) {
- table.set(c);
- }
- }
-
- @Override
- public String toString() {
- StringBuilder description = new StringBuilder("CharMatcher.anyOf(\"");
- for (char c : chars) {
- description.append(showCharacter(c));
- }
- description.append("\")");
- return description.toString();
- }
- }
-
- /** Implementation of {@link #inRange(char, char)}. */
- private static final class InRange extends FastMatcher {
-
- private final char startInclusive;
- private final char endInclusive;
-
- InRange(char startInclusive, char endInclusive) {
- checkArgument(endInclusive >= startInclusive);
- this.startInclusive = startInclusive;
- this.endInclusive = endInclusive;
- }
-
- @Override
- public boolean matches(char c) {
- return startInclusive <= c && c <= endInclusive;
- }
-
- @GwtIncompatible("java.util.BitSet")
- @Override
- void setBits(BitSet table) {
- table.set(startInclusive, endInclusive + 1);
- }
-
- @Override
- public String toString() {
- return "CharMatcher.inRange('"
- + showCharacter(startInclusive)
- + "', '"
- + showCharacter(endInclusive)
- + "')";
- }
- }
-
- /** Implementation of {@link #forPredicate(Predicate)}. */
- private static final class ForPredicate extends CharMatcher {
-
- private final Predicate predicate;
-
- ForPredicate(Predicate predicate) {
- this.predicate = checkNotNull(predicate);
- }
-
- @Override
- public boolean matches(char c) {
- return predicate.apply(c);
- }
-
- @SuppressWarnings("deprecation") // intentional; deprecation is for callers primarily
- @Override
- public boolean apply(Character character) {
- return predicate.apply(checkNotNull(character));
- }
-
- @Override
- public String toString() {
- return "CharMatcher.forPredicate(" + predicate + ")";
- }
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Charsets.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Charsets.java
deleted file mode 100644
index 9aba5c486416..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Charsets.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.GwtCompatible;
-import com.google.common.annotations.GwtIncompatible;
-
-import java.nio.charset.Charset;
-
-/**
- * Contains constant definitions for the six standard {@link Charset} instances, which are
- * guaranteed to be supported by all Java platform implementations.
- *
- *
Assuming you're free to choose, note that {@link #UTF_8} is widely preferred .
- *
- *
See the Guava User Guide article on
- * {@code Charsets} .
- *
- * @author Mike Bostock
- * @since 1.0
- */
-@GwtCompatible(emulated = true)
-public final class Charsets {
- private Charsets() {}
-
- /**
- * US-ASCII: seven-bit ASCII, the Basic Latin block of the Unicode character set (ISO646-US).
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#US_ASCII} instead.
- *
- */
- @GwtIncompatible("Non-UTF-8 Charset")
- public static final Charset US_ASCII = Charset.forName("US-ASCII");
-
- /**
- * ISO-8859-1: ISO Latin Alphabet Number 1 (ISO-LATIN-1).
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#ISO_8859_1} instead.
- *
- */
- @GwtIncompatible("Non-UTF-8 Charset")
- public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
-
- /**
- * UTF-8: eight-bit UCS Transformation Format.
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#UTF_8} instead.
- *
- */
- public static final Charset UTF_8 = Charset.forName("UTF-8");
-
- /**
- * UTF-16BE: sixteen-bit UCS Transformation Format, big-endian byte order.
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#UTF_16BE} instead.
- *
- */
- @GwtIncompatible("Non-UTF-8 Charset")
- public static final Charset UTF_16BE = Charset.forName("UTF-16BE");
-
- /**
- * UTF-16LE: sixteen-bit UCS Transformation Format, little-endian byte order.
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#UTF_16LE} instead.
- *
- */
- @GwtIncompatible("Non-UTF-8 Charset")
- public static final Charset UTF_16LE = Charset.forName("UTF-16LE");
-
- /**
- * UTF-16: sixteen-bit UCS Transformation Format, byte order identified by an optional byte-order
- * mark.
- *
- *
Note for Java 7 and later: this constant should be treated as deprecated; use
- * {@link java.nio.charset.StandardCharsets#UTF_16} instead.
- *
- */
- @GwtIncompatible("Non-UTF-8 Charset")
- public static final Charset UTF_16 = Charset.forName("UTF-16");
-
- /*
- * Please do not add new Charset references to this class, unless those character encodings are
- * part of the set required to be supported by all Java platform implementations! Any Charsets
- * initialized here may cause unexpected delays when this class is loaded. See the Charset
- * Javadocs for the list of built-in character encodings.
- */
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Converter.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Converter.java
deleted file mode 100644
index 40ca53aff203..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Converter.java
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-import java.util.Iterator;
-
-import javax.annotation.Nullable;
-
-/**
- * A function from {@code A} to {@code B} with an associated reverse function from {@code B}
- * to {@code A}; used for converting back and forth between different representations of the same
- * information .
- *
- *
Invertibility
- *
- * The reverse operation may be a strict inverse (meaning that {@code
- * converter.reverse().convert(converter.convert(a)).equals(a)} is always true). However, it is
- * very common (perhaps more common) for round-trip conversion to be lossy . Consider
- * an example round-trip using {@link com.google.common.primitives.Doubles#stringConverter}:
- *
- *
- * {@code stringConverter().convert("1.00")} returns the {@code Double} value {@code 1.0}
- * {@code stringConverter().reverse().convert(1.0)} returns the string {@code "1.0"} --
- * not the same string ({@code "1.00"}) we started with
- *
- *
- * Note that it should still be the case that the round-tripped and original objects are
- * similar .
- *
- *
Nullability
- *
- * A converter always converts {@code null} to {@code null} and non-null references to non-null
- * references. It would not make sense to consider {@code null} and a non-null reference to be
- * "different representations of the same information", since one is distinguishable from
- * missing information and the other is not. The {@link #convert} method handles this null
- * behavior for all converters; implementations of {@link #doForward} and {@link #doBackward} are
- * guaranteed to never be passed {@code null}, and must never return {@code null}.
- *
-
- *
Common ways to use
- *
- * Getting a converter:
- *
- *
- * Use a provided converter implementation, such as {@link Enums#stringConverter}, {@link
- * com.google.common.primitives.Ints#stringConverter Ints.stringConverter} or the {@linkplain
- * #reverse reverse} views of these.
- * Convert between specific preset values using {@link
- * com.google.common.collect.Maps#asConverter Maps.asConverter}. For example, use this to create
- * a "fake" converter for a unit test. It is unnecessary (and confusing) to mock the
- * {@code Converter} type using a mocking framework.
- * Extend this class and implement its {@link #doForward} and {@link #doBackward} methods.
- * If using Java 8, you may prefer to pass two lambda expressions or method references to {@link
- * #from}.
- *
- *
- * Using a converter:
- *
- *
- * Convert one instance in the "forward" direction using {@code converter.convert(a)}.
- * Convert multiple instances "forward" using {@code converter.convertAll(as)}.
- * Convert in the "backward" direction using {@code converter.reverse().convert(b)} or {@code
- * converter.reverse().convertAll(bs)}.
- * Use {@code converter} or {@code converter.reverse()} anywhere a {@link Function} is accepted
- * Do not call {@link #doForward} or {@link #doBackward} directly; these exist only to be
- * overridden.
- *
- *
- * Example
- *
- * {@code
- *
- * return new Converter() {
- * @Override
- * protected String doForward(Integer i) {
- * return Integer.toHexString(i);
- * }
- *
- * @Override
- * protected Integer doBackward(String s) {
- * return parseUnsignedInt(s, 16);
- * }
- * };}
- *
- * An alternative using Java 8:
{@code
- *
- * return Converter.from(Integer::toHexString, s -> parseUnsignedInt(s, 16));}
- *
- * @author Mike Ward
- * @author Kurt Alfred Kluever
- * @author Gregory Kick
- * @since 16.0
- */
-@Beta
-@GwtCompatible
-public abstract class Converter implements Function {
- private final boolean handleNullAutomatically;
-
- // We lazily cache the reverse view to avoid allocating on every call to reverse().
- private transient Converter reverse;
-
- /** Constructor for use by subclasses. */
- protected Converter() {
- this(true);
- }
-
- /**
- * Constructor used only by {@code LegacyConverter} to suspend automatic null-handling.
- */
- Converter(boolean handleNullAutomatically) {
- this.handleNullAutomatically = handleNullAutomatically;
- }
-
- // SPI methods (what subclasses must implement)
-
- /**
- * Returns a representation of {@code a} as an instance of type {@code B}. If {@code a} cannot be
- * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
- *
- * @param a the instance to convert; will never be null
- * @return the converted instance; must not be null
- */
- protected abstract B doForward(A a);
-
- /**
- * Returns a representation of {@code b} as an instance of type {@code A}. If {@code b} cannot be
- * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
- *
- * @param b the instance to convert; will never be null
- * @return the converted instance; must not be null
- * @throws UnsupportedOperationException if backward conversion is not implemented; this should be
- * very rare. Note that if backward conversion is not only unimplemented but
- * unimplementable (for example, consider a {@code Converter}),
- * then this is not logically a {@code Converter} at all, and should just implement {@link
- * Function}.
- */
- protected abstract A doBackward(B b);
-
- // API (consumer-side) methods
-
- /**
- * Returns a representation of {@code a} as an instance of type {@code B}.
- *
- * @return the converted value; is null if and only if {@code a} is null
- */
- @Nullable
- public final B convert(@Nullable A a) {
- return correctedDoForward(a);
- }
-
- @Nullable
- B correctedDoForward(@Nullable A a) {
- if (handleNullAutomatically) {
- // TODO(kevinb): we shouldn't be checking for a null result at runtime. Assert?
- return a == null ? null : checkNotNull(doForward(a));
- } else {
- return doForward(a);
- }
- }
-
- @Nullable
- A correctedDoBackward(@Nullable B b) {
- if (handleNullAutomatically) {
- // TODO(kevinb): we shouldn't be checking for a null result at runtime. Assert?
- return b == null ? null : checkNotNull(doBackward(b));
- } else {
- return doBackward(b);
- }
- }
-
- /**
- * Returns an iterable that applies {@code convert} to each element of {@code fromIterable}. The
- * conversion is done lazily.
- *
- * The returned iterable's iterator supports {@code remove()} if the input iterator does. After
- * a successful {@code remove()} call, {@code fromIterable} no longer contains the corresponding
- * element.
- */
- public Iterable convertAll(final Iterable fromIterable) {
- checkNotNull(fromIterable, "fromIterable");
- return new Iterable() {
- @Override
- public Iterator iterator() {
- return new Iterator() {
- private final Iterator fromIterator = fromIterable.iterator();
-
- @Override
- public boolean hasNext() {
- return fromIterator.hasNext();
- }
-
- @Override
- public B next() {
- return convert(fromIterator.next());
- }
-
- @Override
- public void remove() {
- fromIterator.remove();
- }
- };
- }
- };
- }
-
- /**
- * Returns the reversed view of this converter, which converts {@code this.convert(a)} back to a
- * value roughly equivalent to {@code a}.
- *
- *
The returned converter is serializable if {@code this} converter is.
- */
- // TODO(kak): Make this method final
- public Converter reverse() {
- Converter result = reverse;
- return (result == null) ? reverse = new ReverseConverter(this) : result;
- }
-
- private static final class ReverseConverter extends Converter
- implements Serializable {
- final Converter original;
-
- ReverseConverter(Converter original) {
- this.original = original;
- }
-
- /*
- * These gymnastics are a little confusing. Basically this class has neither legacy nor
- * non-legacy behavior; it just needs to let the behavior of the backing converter shine
- * through. So, we override the correctedDo* methods, after which the do* methods should never
- * be reached.
- */
-
- @Override
- protected A doForward(B b) {
- throw new AssertionError();
- }
-
- @Override
- protected B doBackward(A a) {
- throw new AssertionError();
- }
-
- @Override
- @Nullable
- A correctedDoForward(@Nullable B b) {
- return original.correctedDoBackward(b);
- }
-
- @Override
- @Nullable
- B correctedDoBackward(@Nullable A a) {
- return original.correctedDoForward(a);
- }
-
- @Override
- public Converter reverse() {
- return original;
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof ReverseConverter) {
- ReverseConverter that = (ReverseConverter) object;
- return this.original.equals(that.original);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return ~original.hashCode();
- }
-
- @Override
- public String toString() {
- return original + ".reverse()";
- }
-
- private static final long serialVersionUID = 0L;
- }
-
- /**
- * Returns a converter whose {@code convert} method applies {@code secondConverter} to the result
- * of this converter. Its {@code reverse} method applies the converters in reverse order.
- *
- * The returned converter is serializable if {@code this} converter and {@code secondConverter}
- * are.
- */
- public final Converter andThen(Converter secondConverter) {
- return doAndThen(secondConverter);
- }
-
- /**
- * Package-private non-final implementation of andThen() so only we can override it.
- */
- Converter doAndThen(Converter secondConverter) {
- return new ConverterComposition(this, checkNotNull(secondConverter));
- }
-
- private static final class ConverterComposition extends Converter
- implements Serializable {
- final Converter first;
- final Converter second;
-
- ConverterComposition(Converter first, Converter second) {
- this.first = first;
- this.second = second;
- }
-
- /*
- * These gymnastics are a little confusing. Basically this class has neither legacy nor
- * non-legacy behavior; it just needs to let the behaviors of the backing converters shine
- * through (which might even differ from each other!). So, we override the correctedDo* methods,
- * after which the do* methods should never be reached.
- */
-
- @Override
- protected C doForward(A a) {
- throw new AssertionError();
- }
-
- @Override
- protected A doBackward(C c) {
- throw new AssertionError();
- }
-
- @Override
- @Nullable
- C correctedDoForward(@Nullable A a) {
- return second.correctedDoForward(first.correctedDoForward(a));
- }
-
- @Override
- @Nullable
- A correctedDoBackward(@Nullable C c) {
- return first.correctedDoBackward(second.correctedDoBackward(c));
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof ConverterComposition) {
- ConverterComposition that = (ConverterComposition) object;
- return this.first.equals(that.first) && this.second.equals(that.second);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return 31 * first.hashCode() + second.hashCode();
- }
-
- @Override
- public String toString() {
- return first + ".andThen(" + second + ")";
- }
-
- private static final long serialVersionUID = 0L;
- }
-
- /**
- * @deprecated Provided to satisfy the {@code Function} interface; use {@link #convert} instead.
- */
- @Deprecated
- @Override
- @Nullable
- public final B apply(@Nullable A a) {
- return convert(a);
- }
-
- /**
- * Indicates whether another object is equal to this converter.
- *
- * Most implementations will have no reason to override the behavior of {@link Object#equals}.
- * However, an implementation may also choose to return {@code true} whenever {@code object} is a
- * {@link Converter} that it considers interchangeable with this one. "Interchangeable"
- * typically means that {@code Objects.equal(this.convert(a), that.convert(a))} is true for
- * all {@code a} of type {@code A} (and similarly for {@code reverse}). Note that a {@code false}
- * result from this method does not imply that the converters are known not to be
- * interchangeable.
- */
- @Override
- public boolean equals(@Nullable Object object) {
- return super.equals(object);
- }
-
- // Static converters
-
- /**
- * Returns a converter based on existing forward and backward functions. Note that it is
- * unnecessary to create new classes implementing {@code Function} just to pass them in
- * here. Instead, simply subclass {@code Converter} and implement its {@link #doForward} and
- * {@link #doBackward} methods directly.
- *
- *
These functions will never be passed {@code null} and must not under any circumstances
- * return {@code null}. If a value cannot be converted, the function should throw an unchecked
- * exception (typically, but not necessarily, {@link IllegalArgumentException}).
- *
- *
The returned converter is serializable if both provided functions are.
- *
- * @since 17.0
- */
- public static Converter from(
- Function forwardFunction,
- Function backwardFunction) {
- return new FunctionBasedConverter(forwardFunction, backwardFunction);
- }
-
- private static final class FunctionBasedConverter extends Converter
- implements Serializable {
- private final Function forwardFunction;
- private final Function backwardFunction;
-
- private FunctionBasedConverter(
- Function forwardFunction,
- Function backwardFunction) {
- this.forwardFunction = checkNotNull(forwardFunction);
- this.backwardFunction = checkNotNull(backwardFunction);
- }
-
- @Override
- protected B doForward(A a) {
- return forwardFunction.apply(a);
- }
-
- @Override
- protected A doBackward(B b) {
- return backwardFunction.apply(b);
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof FunctionBasedConverter) {
- FunctionBasedConverter that = (FunctionBasedConverter) object;
- return this.forwardFunction.equals(that.forwardFunction)
- && this.backwardFunction.equals(that.backwardFunction);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return forwardFunction.hashCode() * 31 + backwardFunction.hashCode();
- }
-
- @Override
- public String toString() {
- return "Converter.from(" + forwardFunction + ", " + backwardFunction + ")";
- }
- }
-
- /**
- * Returns a serializable converter that always converts or reverses an object to itself.
- */
- @SuppressWarnings("unchecked") // implementation is "fully variant"
- public static Converter identity() {
- return (IdentityConverter) IdentityConverter.INSTANCE;
- }
-
- /**
- * A converter that always converts or reverses an object to itself. Note that T is now a
- * "pass-through type".
- */
- private static final class IdentityConverter extends Converter implements Serializable {
- static final IdentityConverter INSTANCE = new IdentityConverter();
-
- @Override
- protected T doForward(T t) {
- return t;
- }
-
- @Override
- protected T doBackward(T t) {
- return t;
- }
-
- @Override
- public IdentityConverter reverse() {
- return this;
- }
-
- @Override
- Converter doAndThen(Converter otherConverter) {
- return checkNotNull(otherConverter, "otherConverter");
- }
-
- /*
- * We *could* override convertAll() to return its input, but it's a rather pointless
- * optimization and opened up a weird type-safety problem.
- */
-
- @Override
- public String toString() {
- return "Converter.identity()";
- }
-
- private Object readResolve() {
- return INSTANCE;
- }
-
- private static final long serialVersionUID = 0L;
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Defaults.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Defaults.java
deleted file mode 100644
index bfc22cf0097e..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Defaults.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * This class provides default values for all Java types, as defined by the JLS.
- *
- * @author Ben Yu
- * @since 1.0
- */
-@CheckReturnValue
-public final class Defaults {
- private Defaults() {}
-
- private static final Map, Object> DEFAULTS;
-
- static {
- // Only add to this map via put(Map, Class, T)
- Map, Object> map = new HashMap, Object>();
- put(map, boolean.class, false);
- put(map, char.class, '\0');
- put(map, byte.class, (byte) 0);
- put(map, short.class, (short) 0);
- put(map, int.class, 0);
- put(map, long.class, 0L);
- put(map, float.class, 0f);
- put(map, double.class, 0d);
- DEFAULTS = Collections.unmodifiableMap(map);
- }
-
- private static void put(Map, Object> map, Class type, T value) {
- map.put(type, value);
- }
-
- /**
- * Returns the default value of {@code type} as defined by JLS --- {@code 0} for numbers, {@code
- * false} for {@code boolean} and {@code '\0'} for {@code char}. For non-primitive types and
- * {@code void}, {@code null} is returned.
- */
- @Nullable
- public static T defaultValue(Class type) {
- // Primitives.wrap(type).cast(...) would avoid the warning, but we can't use that from here
- @SuppressWarnings("unchecked") // the put method enforces this key-value relationship
- T t = (T) DEFAULTS.get(checkNotNull(type));
- return t;
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Enums.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Enums.java
deleted file mode 100644
index cbbe08fc277f..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Enums.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-import com.google.common.annotations.GwtIncompatible;
-
-import java.io.Serializable;
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Field;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.WeakHashMap;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Utility methods for working with {@link Enum} instances.
- *
- * @author Steve McKay
- *
- * @since 9.0
- */
-@CheckReturnValue
-@GwtCompatible(emulated = true)
-@Beta
-public final class Enums {
-
- private Enums() {}
-
- /**
- * Returns the {@link Field} in which {@code enumValue} is defined. For example, to get the
- * {@code Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use
- * {@code Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
- *
- * @since 12.0
- */
- @GwtIncompatible("reflection")
- public static Field getField(Enum enumValue) {
- Class clazz = enumValue.getDeclaringClass();
- try {
- return clazz.getDeclaredField(enumValue.name());
- } catch (NoSuchFieldException impossible) {
- throw new AssertionError(impossible);
- }
- }
-
- /**
- * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
- * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
- * user input or falling back to a default enum constant. For example,
- * {@code Enums.getIfPresent(Country.class, countryInput).or(Country.DEFAULT);}
- *
- * @since 12.0
- */
- public static > Optional getIfPresent(Class enumClass, String value) {
- checkNotNull(enumClass);
- checkNotNull(value);
- return Platform.getEnumIfPresent(enumClass, value);
- }
-
- @GwtIncompatible("java.lang.ref.WeakReference")
- private static final Map>, Map>>>
- enumConstantCache =
- new WeakHashMap<
- Class>, Map>>>();
-
- @GwtIncompatible("java.lang.ref.WeakReference")
- private static > Map>> populateCache(
- Class enumClass) {
- Map>> result =
- new HashMap>>();
- for (T enumInstance : EnumSet.allOf(enumClass)) {
- result.put(enumInstance.name(), new WeakReference>(enumInstance));
- }
- enumConstantCache.put(enumClass, result);
- return result;
- }
-
- @GwtIncompatible("java.lang.ref.WeakReference")
- static > Map>> getEnumConstants(
- Class enumClass) {
- synchronized (enumConstantCache) {
- Map>> constants = enumConstantCache.get(enumClass);
- if (constants == null) {
- constants = populateCache(enumClass);
- }
- return constants;
- }
- }
-
- /**
- * Returns a converter that converts between strings and {@code enum} values of type
- * {@code enumClass} using {@link Enum#valueOf(Class, String)} and {@link Enum#name()}. The
- * converter will throw an {@code IllegalArgumentException} if the argument is not the name of
- * any enum constant in the specified enum.
- *
- * @since 16.0
- */
- public static > Converter stringConverter(final Class enumClass) {
- return new StringConverter(enumClass);
- }
-
- private static final class StringConverter> extends Converter
- implements Serializable {
-
- private final Class enumClass;
-
- StringConverter(Class enumClass) {
- this.enumClass = checkNotNull(enumClass);
- }
-
- @Override
- protected T doForward(String value) {
- return Enum.valueOf(enumClass, value);
- }
-
- @Override
- protected String doBackward(T enumValue) {
- return enumValue.name();
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof StringConverter) {
- StringConverter that = (StringConverter) object;
- return this.enumClass.equals(that.enumClass);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return enumClass.hashCode();
- }
-
- @Override
- public String toString() {
- return "Enums.stringConverter(" + enumClass.getName() + ".class)";
- }
-
- private static final long serialVersionUID = 0L;
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Equivalence.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Equivalence.java
deleted file mode 100644
index 344454f2dd7d..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Equivalence.java
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * Copyright (C) 2010 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * A strategy for determining whether two instances are considered equivalent. Examples of
- * equivalences are the {@linkplain #identity() identity equivalence} and {@linkplain #equals equals
- * equivalence}.
- *
- * @author Bob Lee
- * @author Ben Yu
- * @author Gregory Kick
- * @since 10.0 (mostly source-compatible since 4.0)
- */
-@CheckReturnValue
-@GwtCompatible
-public abstract class Equivalence {
- /**
- * Constructor for use by subclasses.
- */
- protected Equivalence() {}
-
- /**
- * Returns {@code true} if the given objects are considered equivalent.
- *
- * The {@code equivalent} method implements an equivalence relation on object references:
- *
- *
- * It is reflexive : for any reference {@code x}, including null, {@code
- * equivalent(x, x)} returns {@code true}.
- * It is symmetric : for any references {@code x} and {@code y}, {@code
- * equivalent(x, y) == equivalent(y, x)}.
- * It is transitive : for any references {@code x}, {@code y}, and {@code z}, if
- * {@code equivalent(x, y)} returns {@code true} and {@code equivalent(y, z)} returns {@code
- * true}, then {@code equivalent(x, z)} returns {@code true}.
- * It is consistent : for any references {@code x} and {@code y}, multiple invocations
- * of {@code equivalent(x, y)} consistently return {@code true} or consistently return {@code
- * false} (provided that neither {@code x} nor {@code y} is modified).
- *
- */
- public final boolean equivalent(@Nullable T a, @Nullable T b) {
- if (a == b) {
- return true;
- }
- if (a == null || b == null) {
- return false;
- }
- return doEquivalent(a, b);
- }
-
- /**
- * Returns {@code true} if {@code a} and {@code b} are considered equivalent.
- *
- * Called by {@link #equivalent}. {@code a} and {@code b} are not the same
- * object and are not nulls.
- *
- * @since 10.0 (previously, subclasses would override equivalent())
- */
- protected abstract boolean doEquivalent(T a, T b);
-
- /**
- * Returns a hash code for {@code t}.
- *
- *
The {@code hash} has the following properties:
- *
- * It is consistent : for any reference {@code x}, multiple invocations of
- * {@code hash(x}} consistently return the same value provided {@code x} remains unchanged
- * according to the definition of the equivalence. The hash need not remain consistent from
- * one execution of an application to another execution of the same application.
- * It is distributable across equivalence : for any references {@code x} and {@code y},
- * if {@code equivalent(x, y)}, then {@code hash(x) == hash(y)}. It is not necessary
- * that the hash be distributable across inequivalence . If {@code equivalence(x, y)}
- * is false, {@code hash(x) == hash(y)} may still be true.
- * {@code hash(null)} is {@code 0}.
- *
- */
- public final int hash(@Nullable T t) {
- if (t == null) {
- return 0;
- }
- return doHash(t);
- }
-
- /**
- * Returns a hash code for non-null object {@code t}.
- *
- * Called by {@link #hash}.
- *
- * @since 10.0 (previously, subclasses would override hash())
- */
- protected abstract int doHash(T t);
-
- /**
- * Returns a new equivalence relation for {@code F} which evaluates equivalence by first applying
- * {@code function} to the argument, then evaluating using {@code this}. That is, for any pair of
- * non-null objects {@code x} and {@code y}, {@code
- * equivalence.onResultOf(function).equivalent(a, b)} is true if and only if {@code
- * equivalence.equivalent(function.apply(a), function.apply(b))} is true.
- *
- *
For example:
- *
- *
{@code
- * Equivalence SAME_AGE = Equivalence.equals().onResultOf(GET_PERSON_AGE);}
- *
- * {@code function} will never be invoked with a null value.
- *
- *
Note that {@code function} must be consistent according to {@code this} equivalence
- * relation. That is, invoking {@link Function#apply} multiple times for a given value must return
- * equivalent results.
- * For example, {@code Equivalence.identity().onResultOf(Functions.toStringFunction())} is broken
- * because it's not guaranteed that {@link Object#toString}) always returns the same string
- * instance.
- *
- * @since 10.0
- */
- public final Equivalence onResultOf(Function function) {
- return new FunctionalEquivalence(function, this);
- }
-
- /**
- * Returns a wrapper of {@code reference} that implements
- * {@link Wrapper#equals(Object) Object.equals()} such that
- * {@code wrap(a).equals(wrap(b))} if and only if {@code equivalent(a, b)}.
- *
- * @since 10.0
- */
- public final Wrapper wrap(@Nullable S reference) {
- return new Wrapper(this, reference);
- }
-
- /**
- * Wraps an object so that {@link #equals(Object)} and {@link #hashCode()} delegate to an
- * {@link Equivalence}.
- *
- * For example, given an {@link Equivalence} for {@link String strings} named {@code equiv}
- * that tests equivalence using their lengths:
- *
- *
{@code
- * equiv.wrap("a").equals(equiv.wrap("b")) // true
- * equiv.wrap("a").equals(equiv.wrap("hello")) // false}
- *
- * Note in particular that an equivalence wrapper is never equal to the object it wraps.
- *
- *
{@code
- * equiv.wrap(obj).equals(obj) // always false}
- *
- * @since 10.0
- */
- public static final class Wrapper implements Serializable {
- private final Equivalence equivalence;
- @Nullable private final T reference;
-
- private Wrapper(Equivalence equivalence, @Nullable T reference) {
- this.equivalence = checkNotNull(equivalence);
- this.reference = reference;
- }
-
- /** Returns the (possibly null) reference wrapped by this instance. */
- @Nullable
- public T get() {
- return reference;
- }
-
- /**
- * Returns {@code true} if {@link Equivalence#equivalent(Object, Object)} applied to the wrapped
- * references is {@code true} and both wrappers use the {@link Object#equals(Object) same}
- * equivalence.
- */
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj == this) {
- return true;
- }
- if (obj instanceof Wrapper) {
- Wrapper that = (Wrapper) obj; // note: not necessarily a Wrapper
-
- if (this.equivalence.equals(that.equivalence)) {
- /*
- * We'll accept that as sufficient "proof" that either equivalence should be able to
- * handle either reference, so it's safe to circumvent compile-time type checking.
- */
- @SuppressWarnings("unchecked")
- Equivalence equivalence = (Equivalence) this.equivalence;
- return equivalence.equivalent(this.reference, that.reference);
- }
- }
- return false;
- }
-
- /**
- * Returns the result of {@link Equivalence#hash(Object)} applied to the wrapped reference.
- */
- @Override
- public int hashCode() {
- return equivalence.hash(reference);
- }
-
- /**
- * Returns a string representation for this equivalence wrapper. The form of this string
- * representation is not specified.
- */
- @Override
- public String toString() {
- return equivalence + ".wrap(" + reference + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Returns an equivalence over iterables based on the equivalence of their elements. More
- * specifically, two iterables are considered equivalent if they both contain the same number of
- * elements, and each pair of corresponding elements is equivalent according to
- * {@code this}. Null iterables are equivalent to one another.
- *
- * Note that this method performs a similar function for equivalences as {@link
- * com.google.common.collect.Ordering#lexicographical} does for orderings.
- *
- * @since 10.0
- */
- @GwtCompatible(serializable = true)
- public final Equivalence> pairwise() {
- // Ideally, the returned equivalence would support Iterable. However,
- // the need for this is so rare that it's not worth making callers deal with the ugly wildcard.
- return new PairwiseEquivalence(this);
- }
-
- /**
- * Returns a predicate that evaluates to true if and only if the input is
- * equivalent to {@code target} according to this equivalence relation.
- *
- * @since 10.0
- */
- @Beta
- public final Predicate equivalentTo(@Nullable T target) {
- return new EquivalentToPredicate(this, target);
- }
-
- private static final class EquivalentToPredicate implements Predicate, Serializable {
-
- private final Equivalence equivalence;
- @Nullable private final T target;
-
- EquivalentToPredicate(Equivalence equivalence, @Nullable T target) {
- this.equivalence = checkNotNull(equivalence);
- this.target = target;
- }
-
- @Override
- public boolean apply(@Nullable T input) {
- return equivalence.equivalent(input, target);
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj instanceof EquivalentToPredicate) {
- EquivalentToPredicate that = (EquivalentToPredicate) obj;
- return equivalence.equals(that.equivalence) && Objects.equal(target, that.target);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(equivalence, target);
- }
-
- @Override
- public String toString() {
- return equivalence + ".equivalentTo(" + target + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Returns an equivalence that delegates to {@link Object#equals} and {@link Object#hashCode}.
- * {@link Equivalence#equivalent} returns {@code true} if both values are null, or if neither
- * value is null and {@link Object#equals} returns {@code true}. {@link Equivalence#hash} returns
- * {@code 0} if passed a null value.
- *
- * @since 13.0
- * @since 8.0 (in Equivalences with null-friendly behavior)
- * @since 4.0 (in Equivalences)
- */
- public static Equivalence equals() {
- return Equals.INSTANCE;
- }
-
- /**
- * Returns an equivalence that uses {@code ==} to compare values and {@link
- * System#identityHashCode(Object)} to compute the hash code. {@link Equivalence#equivalent}
- * returns {@code true} if {@code a == b}, including in the case that a and b are both null.
- *
- * @since 13.0
- * @since 4.0 (in Equivalences)
- */
- public static Equivalence identity() {
- return Identity.INSTANCE;
- }
-
- static final class Equals extends Equivalence implements Serializable {
-
- static final Equals INSTANCE = new Equals();
-
- @Override
- protected boolean doEquivalent(Object a, Object b) {
- return a.equals(b);
- }
-
- @Override
- protected int doHash(Object o) {
- return o.hashCode();
- }
-
- private Object readResolve() {
- return INSTANCE;
- }
-
- private static final long serialVersionUID = 1;
- }
-
- static final class Identity extends Equivalence implements Serializable {
-
- static final Identity INSTANCE = new Identity();
-
- @Override
- protected boolean doEquivalent(Object a, Object b) {
- return false;
- }
-
- @Override
- protected int doHash(Object o) {
- return System.identityHashCode(o);
- }
-
- private Object readResolve() {
- return INSTANCE;
- }
-
- private static final long serialVersionUID = 1;
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizablePhantomReference.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizablePhantomReference.java
deleted file mode 100644
index 952143e3cc02..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizablePhantomReference.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import java.lang.ref.PhantomReference;
-import java.lang.ref.ReferenceQueue;
-
-/**
- * Phantom reference with a {@code finalizeReferent()} method which a background thread invokes
- * after the garbage collector reclaims the referent. This is a simpler alternative to using a
- * {@link ReferenceQueue}.
- *
- * Unlike a normal phantom reference, this reference will be cleared automatically.
- *
- * @author Bob Lee
- * @since 2.0
- */
-public abstract class FinalizablePhantomReference extends PhantomReference
- implements FinalizableReference {
- /**
- * Constructs a new finalizable phantom reference.
- *
- * @param referent to phantom reference
- * @param queue that should finalize the referent
- */
- protected FinalizablePhantomReference(T referent, FinalizableReferenceQueue queue) {
- super(referent, queue.queue);
- queue.cleanUp();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReference.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReference.java
deleted file mode 100644
index acc6efc02e5d..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReference.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-/**
- * Implemented by references that have code to run after garbage collection of their referents.
- *
- * @see FinalizableReferenceQueue
- * @author Bob Lee
- * @since 2.0
- */
-public interface FinalizableReference {
- /**
- * Invoked on a background thread after the referent has been garbage collected unless security
- * restrictions prevented starting a background thread, in which case this method is invoked when
- * new references are created.
- */
- void finalizeReferent();
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReferenceQueue.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReferenceQueue.java
deleted file mode 100644
index b98cd975547c..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableReferenceQueue.java
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.VisibleForTesting;
-
-import java.io.Closeable;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.lang.ref.PhantomReference;
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-import com.google.common.logging.Level;
-import com.google.common.logging.Logger;
-
-import javax.annotation.Nullable;
-
-/**
- * A reference queue with an associated background thread that dequeues references and invokes
- * {@link FinalizableReference#finalizeReferent()} on them.
- *
- * Keep a strong reference to this object until all of the associated referents have been
- * finalized. If this object is garbage collected earlier, the backing thread will not invoke {@code
- * finalizeReferent()} on the remaining references.
- *
- *
As an example of how this is used, imagine you have a class {@code MyServer} that creates a
- * a {@link java.net.ServerSocket ServerSocket}, and you would like to ensure that the
- * {@code ServerSocket} is closed even if the {@code MyServer} object is garbage-collected without
- * calling its {@code close} method. You could use a finalizer to accomplish this, but
- * that has a number of well-known problems. Here is how you might use this class instead:
- *
- *
- * public class MyServer implements Closeable {
- * private static final FinalizableReferenceQueue frq = new FinalizableReferenceQueue();
- * // You might also share this between several objects.
- *
- * private static final Set<Reference<?>> references = Sets.newConcurrentHashSet();
- * // This ensures that the FinalizablePhantomReference itself is not garbage-collected.
- *
- * private final ServerSocket serverSocket;
- *
- * private MyServer(...) {
- * ...
- * this.serverSocket = new ServerSocket(...);
- * ...
- * }
- *
- * public static MyServer create(...) {
- * MyServer myServer = new MyServer(...);
- * final ServerSocket serverSocket = myServer.serverSocket;
- * Reference<?> reference = new FinalizablePhantomReference<MyServer>(myServer, frq) {
- * @Override public void finalizeReferent() {
- * references.remove(this):
- * if (!serverSocket.isClosed()) {
- * ...log a message about how nobody called close()...
- * try {
- * serverSocket.close();
- * } catch (IOException e) {
- * ...
- * }
- * }
- * }
- * };
- * references.add(reference);
- * return myServer;
- * }
- *
- * @Override public void close() {
- * serverSocket.close();
- * }
- * }
- *
- *
- * @author Bob Lee
- * @since 2.0
- */
-public class FinalizableReferenceQueue implements Closeable {
- /*
- * The Finalizer thread keeps a phantom reference to this object. When the client (for example, a
- * map built by MapMaker) no longer has a strong reference to this object, the garbage collector
- * will reclaim it and enqueue the phantom reference. The enqueued reference will trigger the
- * Finalizer to stop.
- *
- * If this library is loaded in the system class loader, FinalizableReferenceQueue can load
- * Finalizer directly with no problems.
- *
- * If this library is loaded in an application class loader, it's important that Finalizer not
- * have a strong reference back to the class loader. Otherwise, you could have a graph like this:
- *
- * Finalizer Thread runs instance of -> Finalizer.class loaded by -> Application class loader
- * which loaded -> ReferenceMap.class which has a static -> FinalizableReferenceQueue instance
- *
- * Even if no other references to classes from the application class loader remain, the Finalizer
- * thread keeps an indirect strong reference to the queue in ReferenceMap, which keeps the
- * Finalizer running, and as a result, the application class loader can never be reclaimed.
- *
- * This means that dynamically loaded web applications and OSGi bundles can't be unloaded.
- *
- * If the library is loaded in an application class loader, we try to break the cycle by loading
- * Finalizer in its own independent class loader:
- *
- * System class loader -> Application class loader -> ReferenceMap -> FinalizableReferenceQueue
- * -> etc. -> Decoupled class loader -> Finalizer
- *
- * Now, Finalizer no longer keeps an indirect strong reference to the static
- * FinalizableReferenceQueue field in ReferenceMap. The application class loader can be reclaimed
- * at which point the Finalizer thread will stop and its decoupled class loader can also be
- * reclaimed.
- *
- * If any of this fails along the way, we fall back to loading Finalizer directly in the
- * application class loader.
- */
-
- private static final Logger logger = Logger.getLogger(FinalizableReferenceQueue.class.getName());
-
- private static final String FINALIZER_CLASS_NAME = "com.google.common.base.internal.Finalizer";
-
- /** Reference to Finalizer.startFinalizer(). */
- private static final Method startFinalizer;
-
- static {
- Class finalizer =
- loadFinalizer(new SystemLoader(), new DecoupledLoader(), new DirectLoader());
- startFinalizer = getStartFinalizer(finalizer);
- }
-
- /**
- * The actual reference queue that our background thread will poll.
- */
- final ReferenceQueue queue;
-
- final PhantomReference frqRef;
-
- /**
- * Whether or not the background thread started successfully.
- */
- final boolean threadStarted;
-
- /**
- * Constructs a new queue.
- */
- public FinalizableReferenceQueue() {
- // We could start the finalizer lazily, but I'd rather it blow up early.
- queue = new ReferenceQueue();
- frqRef = new PhantomReference(this, queue);
- boolean threadStarted = false;
- try {
- startFinalizer.invoke(null, FinalizableReference.class, queue, frqRef);
- threadStarted = true;
- } catch (IllegalAccessException impossible) {
- throw new AssertionError(impossible); // startFinalizer() is public
- } catch (Throwable t) {
- logger.log(
- Level.INFO,
- "Failed to start reference finalizer thread."
- + " Reference cleanup will only occur when new references are created.",
- t);
- }
-
- this.threadStarted = threadStarted;
- }
-
- @Override
- public void close() {
- frqRef.enqueue();
- cleanUp();
- }
-
- /**
- * Repeatedly dequeues references from the queue and invokes {@link
- * FinalizableReference#finalizeReferent()} on them until the queue is empty. This method is a
- * no-op if the background thread was created successfully.
- */
- void cleanUp() {
- if (threadStarted) {
- return;
- }
-
- Reference reference;
- while ((reference = queue.poll()) != null) {
- /*
- * This is for the benefit of phantom references. Weak and soft references will have already
- * been cleared by this point.
- */
- reference.clear();
- try {
- ((FinalizableReference) reference).finalizeReferent();
- } catch (Throwable t) {
- logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
- }
- }
- }
-
- /**
- * Iterates through the given loaders until it finds one that can load Finalizer.
- *
- * @return Finalizer.class
- */
- private static Class loadFinalizer(FinalizerLoader... loaders) {
- for (FinalizerLoader loader : loaders) {
- Class finalizer = loader.loadFinalizer();
- if (finalizer != null) {
- return finalizer;
- }
- }
-
- throw new AssertionError();
- }
-
- /**
- * Loads Finalizer.class.
- */
- interface FinalizerLoader {
-
- /**
- * Returns Finalizer.class or null if this loader shouldn't or can't load it.
- *
- * @throws SecurityException if we don't have the appropriate privileges
- */
- @Nullable
- Class loadFinalizer();
- }
-
- /**
- * Tries to load Finalizer from the system class loader. If Finalizer is in the system class path,
- * we needn't create a separate loader.
- */
- static class SystemLoader implements FinalizerLoader {
- // This is used by the ClassLoader-leak test in FinalizableReferenceQueueTest to disable
- // finding Finalizer on the system class path even if it is there.
- @VisibleForTesting static boolean disabled;
-
- @Override
- public Class loadFinalizer() {
- if (disabled) {
- return null;
- }
- ClassLoader systemLoader;
- try {
- systemLoader = ClassLoader.getSystemClassLoader();
- } catch (SecurityException e) {
- logger.info("Not allowed to access system class loader.");
- return null;
- }
- if (systemLoader != null) {
- try {
- return systemLoader.loadClass(FINALIZER_CLASS_NAME);
- } catch (ClassNotFoundException e) {
- // Ignore. Finalizer is simply in a child class loader.
- return null;
- }
- } else {
- return null;
- }
- }
- }
-
- /**
- * Try to load Finalizer in its own class loader. If Finalizer's thread had a direct reference to
- * our class loader (which could be that of a dynamically loaded web application or OSGi bundle),
- * it would prevent our class loader from getting garbage collected.
- */
- static class DecoupledLoader implements FinalizerLoader {
- private static final String LOADING_ERROR =
- "Could not load Finalizer in its own class loader. Loading Finalizer in the current class "
- + "loader instead. As a result, you will not be able to garbage collect this class "
- + "loader. To support reclaiming this class loader, either resolve the underlying "
- + "issue, or move Guava to your system class path.";
-
- @Override
- public Class loadFinalizer() {
- try {
- /*
- * We use URLClassLoader because it's the only concrete class loader implementation in the
- * JDK. If we used our own ClassLoader subclass, Finalizer would indirectly reference this
- * class loader:
- *
- * Finalizer.class -> CustomClassLoader -> CustomClassLoader.class -> This class loader
- *
- * System class loader will (and must) be the parent.
- */
- ClassLoader finalizerLoader = newLoader(getBaseUrl());
- return finalizerLoader.loadClass(FINALIZER_CLASS_NAME);
- } catch (Exception e) {
- logger.log(Level.WARNING, LOADING_ERROR, e);
- return null;
- }
- }
-
- /**
- * Gets URL for base of path containing Finalizer.class.
- */
- URL getBaseUrl() throws IOException {
- // Find URL pointing to Finalizer.class file.
- String finalizerPath = FINALIZER_CLASS_NAME.replace('.', '/') + ".class";
- URL finalizerUrl = getClass().getClassLoader().getResource(finalizerPath);
- if (finalizerUrl == null) {
- throw new FileNotFoundException(finalizerPath);
- }
-
- // Find URL pointing to base of class path.
- String urlString = finalizerUrl.toString();
- if (!urlString.endsWith(finalizerPath)) {
- throw new IOException("Unsupported path style: " + urlString);
- }
- urlString = urlString.substring(0, urlString.length() - finalizerPath.length());
- return new URL(finalizerUrl, urlString);
- }
-
- /** Creates a class loader with the given base URL as its classpath. */
- URLClassLoader newLoader(URL base) {
- // We use the bootstrap class loader as the parent because Finalizer by design uses
- // only standard Java classes. That also means that FinalizableReferenceQueueTest
- // doesn't pick up the wrong version of the Finalizer class.
- return new URLClassLoader(new URL[] {base}, null);
- }
- }
-
- /**
- * Loads Finalizer directly using the current class loader. We won't be able to garbage collect
- * this class loader, but at least the world doesn't end.
- */
- static class DirectLoader implements FinalizerLoader {
- @Override
- public Class loadFinalizer() {
- try {
- return Class.forName(FINALIZER_CLASS_NAME);
- } catch (ClassNotFoundException e) {
- throw new AssertionError(e);
- }
- }
- }
-
- /**
- * Looks up Finalizer.startFinalizer().
- */
- static Method getStartFinalizer(Class finalizer) {
- try {
- return finalizer.getMethod(
- "startFinalizer", Class.class, ReferenceQueue.class, PhantomReference.class);
- } catch (NoSuchMethodException e) {
- throw new AssertionError(e);
- }
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableSoftReference.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableSoftReference.java
deleted file mode 100644
index 74726c142da7..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableSoftReference.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.SoftReference;
-
-/**
- * Soft reference with a {@code finalizeReferent()} method which a background thread invokes after
- * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
- * ReferenceQueue}.
- *
- * @author Bob Lee
- * @since 2.0
- */
-public abstract class FinalizableSoftReference extends SoftReference
- implements FinalizableReference {
- /**
- * Constructs a new finalizable soft reference.
- *
- * @param referent to softly reference
- * @param queue that should finalize the referent
- */
- protected FinalizableSoftReference(T referent, FinalizableReferenceQueue queue) {
- super(referent, queue.queue);
- queue.cleanUp();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableWeakReference.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableWeakReference.java
deleted file mode 100644
index d128df52c83e..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FinalizableWeakReference.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
-
-/**
- * Weak reference with a {@code finalizeReferent()} method which a background thread invokes after
- * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
- * ReferenceQueue}.
- *
- * @author Bob Lee
- * @since 2.0
- */
-public abstract class FinalizableWeakReference extends WeakReference
- implements FinalizableReference {
- /**
- * Constructs a new finalizable weak reference.
- *
- * @param referent to weakly reference
- * @param queue that should finalize the referent
- */
- protected FinalizableWeakReference(T referent, FinalizableReferenceQueue queue) {
- super(referent, queue.queue);
- queue.cleanUp();
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Function.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Function.java
deleted file mode 100644
index f39e2eab57ac..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Function.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.GwtCompatible;
-
-import javax.annotation.Nullable;
-
-/**
- * Determines an output value based on an input value.
- *
- * The {@link Functions} class provides common functions and related utilites.
- *
- *
See the Guava User Guide article on the use of {@code
- * Function} .
- *
- * @author Kevin Bourrillion
- * @since 2.0
- */
-@GwtCompatible
-public interface Function {
- /**
- * Returns the result of applying this function to {@code input}. This method is generally
- * expected , but not absolutely required, to have the following properties:
- *
- *
- * Its execution does not cause any observable side effects.
- * The computation is consistent with equals ; that is, {@link Objects#equal
- * Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
- * function.apply(b))}.
- *
- *
- * @throws NullPointerException if {@code input} is null and this function does not accept null
- * arguments
- */
- @Nullable
- T apply(@Nullable F input);
-
- /**
- * Indicates whether another object is equal to this function.
- *
- * Most implementations will have no reason to override the behavior of {@link Object#equals}.
- * However, an implementation may also choose to return {@code true} whenever {@code object} is a
- * {@link Function} that it considers interchangeable with this one. "Interchangeable"
- * typically means that {@code Objects.equal(this.apply(f), that.apply(f))} is true for all
- * {@code f} of type {@code F}. Note that a {@code false} result from this method does not imply
- * that the functions are known not to be interchangeable.
- */
- @Override
- boolean equals(@Nullable Object object);
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/FunctionalEquivalence.java b/thirdparty/google-guava/src/main/java/com/google/common/base/FunctionalEquivalence.java
deleted file mode 100644
index c28f6b95d651..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/FunctionalEquivalence.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-
-import javax.annotation.Nullable;
-
-/**
- * Equivalence applied on functional result.
- *
- * @author Bob Lee
- * @since 10.0
- */
-@Beta
-@GwtCompatible
-final class FunctionalEquivalence extends Equivalence implements Serializable {
-
- private static final long serialVersionUID = 0;
-
- private final Function function;
- private final Equivalence resultEquivalence;
-
- FunctionalEquivalence(Function function, Equivalence resultEquivalence) {
- this.function = checkNotNull(function);
- this.resultEquivalence = checkNotNull(resultEquivalence);
- }
-
- @Override
- protected boolean doEquivalent(F a, F b) {
- return resultEquivalence.equivalent(function.apply(a), function.apply(b));
- }
-
- @Override
- protected int doHash(F a) {
- return resultEquivalence.hash(function.apply(a));
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj == this) {
- return true;
- }
- if (obj instanceof FunctionalEquivalence) {
- FunctionalEquivalence that = (FunctionalEquivalence) obj;
- return function.equals(that.function) && resultEquivalence.equals(that.resultEquivalence);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(function, resultEquivalence);
- }
-
- @Override
- public String toString() {
- return resultEquivalence + ".onResultOf(" + function + ")";
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Functions.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Functions.java
deleted file mode 100644
index da5626d6a8d4..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Functions.java
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-import java.util.Map;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Static utility methods pertaining to {@code Function} instances.
- *
- * All methods return serializable functions as long as they're given serializable parameters.
- *
- *
See the Guava User Guide article on the use of {@code
- * Function} .
- *
- * @author Mike Bostock
- * @author Jared Levy
- * @since 2.0
- */
-@GwtCompatible
-@CheckReturnValue
-public final class Functions {
- private Functions() {}
-
- /**
- * Returns a function that calls {@code toString()} on its argument. The function does not accept
- * nulls; it will throw a {@link NullPointerException} when applied to {@code null}.
- *
- *
Warning: The returned function may not be consistent with equals (as
- * documented at {@link Function#apply}). For example, this function yields different results for
- * the two equal instances {@code ImmutableSet.of(1, 2)} and {@code ImmutableSet.of(2, 1)}.
- */
- public static Function toStringFunction() {
- return ToStringFunction.INSTANCE;
- }
-
- // enum singleton pattern
- private enum ToStringFunction implements Function {
- INSTANCE;
-
- @Override
- public String apply(Object o) {
- checkNotNull(o); // eager for GWT.
- return o.toString();
- }
-
- @Override
- public String toString() {
- return "Functions.toStringFunction()";
- }
- }
-
- /**
- * Returns the identity function.
- */
- // implementation is "fully variant"; E has become a "pass-through" type
- @SuppressWarnings("unchecked")
- public static Function identity() {
- return (Function) IdentityFunction.INSTANCE;
- }
-
- // enum singleton pattern
- private enum IdentityFunction implements Function {
- INSTANCE;
-
- @Override
- @Nullable
- public Object apply(@Nullable Object o) {
- return o;
- }
-
- @Override
- public String toString() {
- return "Functions.identity()";
- }
- }
-
- /**
- * Returns a function which performs a map lookup. The returned function throws an {@link
- * IllegalArgumentException} if given a key that does not exist in the map. See also {@link
- * #forMap(Map, Object)}, which returns a default value in this case.
- *
- * Note: if {@code map} is a {@link com.google.common.collect.BiMap BiMap} (or can be one), you
- * can use {@link com.google.common.collect.Maps#asConverter Maps.asConverter} instead to get a
- * function that also supports reverse conversion.
- */
- public static Function forMap(Map map) {
- return new FunctionForMapNoDefault(map);
- }
-
- private static class FunctionForMapNoDefault implements Function, Serializable {
- final Map map;
-
- FunctionForMapNoDefault(Map map) {
- this.map = checkNotNull(map);
- }
-
- @Override
- public V apply(@Nullable K key) {
- V result = map.get(key);
- checkArgument(result != null || map.containsKey(key), "Key '%s' not present in map", key);
- return result;
- }
-
- @Override
- public boolean equals(@Nullable Object o) {
- if (o instanceof FunctionForMapNoDefault) {
- FunctionForMapNoDefault that = (FunctionForMapNoDefault) o;
- return map.equals(that.map);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return map.hashCode();
- }
-
- @Override
- public String toString() {
- return "Functions.forMap(" + map + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Returns a function which performs a map lookup with a default value. The function created by
- * this method returns {@code defaultValue} for all inputs that do not belong to the map's key
- * set. See also {@link #forMap(Map)}, which throws an exception in this case.
- *
- * @param map source map that determines the function behavior
- * @param defaultValue the value to return for inputs that aren't map keys
- * @return function that returns {@code map.get(a)} when {@code a} is a key, or {@code
- * defaultValue} otherwise
- */
- public static Function forMap(Map map, @Nullable V defaultValue) {
- return new ForMapWithDefault(map, defaultValue);
- }
-
- private static class ForMapWithDefault implements Function, Serializable {
- final Map map;
- final V defaultValue;
-
- ForMapWithDefault(Map map, @Nullable V defaultValue) {
- this.map = checkNotNull(map);
- this.defaultValue = defaultValue;
- }
-
- @Override
- public V apply(@Nullable K key) {
- V result = map.get(key);
- return (result != null || map.containsKey(key)) ? result : defaultValue;
- }
-
- @Override
- public boolean equals(@Nullable Object o) {
- if (o instanceof ForMapWithDefault) {
- ForMapWithDefault that = (ForMapWithDefault) o;
- return map.equals(that.map) && Objects.equal(defaultValue, that.defaultValue);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return Objects.hashCode(map, defaultValue);
- }
-
- @Override
- public String toString() {
- // TODO(cpovirk): maybe remove "defaultValue=" to make this look like the method call does
- return "Functions.forMap(" + map + ", defaultValue=" + defaultValue + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Returns the composition of two functions. For {@code f: A->B} and {@code g: B->C}, composition
- * is defined as the function h such that {@code h(a) == g(f(a))} for each {@code a}.
- *
- * @param g the second function to apply
- * @param f the first function to apply
- * @return the composition of {@code f} and {@code g}
- * @see function composition
- */
- public static Function compose(Function g, Function f) {
- return new FunctionComposition(g, f);
- }
-
- private static class FunctionComposition implements Function, Serializable {
- private final Function g;
- private final Function f;
-
- public FunctionComposition(Function g, Function f) {
- this.g = checkNotNull(g);
- this.f = checkNotNull(f);
- }
-
- @Override
- public C apply(@Nullable A a) {
- return g.apply(f.apply(a));
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj instanceof FunctionComposition) {
- FunctionComposition that = (FunctionComposition) obj;
- return f.equals(that.f) && g.equals(that.g);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return f.hashCode() ^ g.hashCode();
- }
-
- @Override
- public String toString() {
- // TODO(cpovirk): maybe make this look like the method call does ("Functions.compose(...)")
- return g + "(" + f + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Creates a function that returns the same boolean output as the given predicate for all inputs.
- *
- * The returned function is consistent with equals (as documented at {@link
- * Function#apply}) if and only if {@code predicate} is itself consistent with equals.
- */
- public static Function forPredicate(Predicate predicate) {
- return new PredicateFunction(predicate);
- }
-
- /** @see Functions#forPredicate */
- private static class PredicateFunction implements Function, Serializable {
- private final Predicate predicate;
-
- private PredicateFunction(Predicate predicate) {
- this.predicate = checkNotNull(predicate);
- }
-
- @Override
- public Boolean apply(@Nullable T t) {
- return predicate.apply(t);
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj instanceof PredicateFunction) {
- PredicateFunction that = (PredicateFunction) obj;
- return predicate.equals(that.predicate);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return predicate.hashCode();
- }
-
- @Override
- public String toString() {
- return "Functions.forPredicate(" + predicate + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Creates a function that returns {@code value} for any input.
- *
- * @param value the constant value for the function to return
- * @return a function that always returns {@code value}
- */
- public static Function constant(@Nullable E value) {
- return new ConstantFunction(value);
- }
-
- private static class ConstantFunction implements Function, Serializable {
- private final E value;
-
- public ConstantFunction(@Nullable E value) {
- this.value = value;
- }
-
- @Override
- public E apply(@Nullable Object from) {
- return value;
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj instanceof ConstantFunction) {
- ConstantFunction that = (ConstantFunction) obj;
- return Objects.equal(value, that.value);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return (value == null) ? 0 : value.hashCode();
- }
-
- @Override
- public String toString() {
- return "Functions.constant(" + value + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-
- /**
- * Returns a function that always returns the result of invoking {@link Supplier#get} on {@code
- * supplier}, regardless of its input.
- *
- * @since 10.0
- */
- @Beta
- public static Function forSupplier(Supplier supplier) {
- return new SupplierFunction(supplier);
- }
-
- /** @see Functions#forSupplier*/
- private static class SupplierFunction implements Function, Serializable {
-
- private final Supplier supplier;
-
- private SupplierFunction(Supplier supplier) {
- this.supplier = checkNotNull(supplier);
- }
-
- @Override
- public T apply(@Nullable Object input) {
- return supplier.get();
- }
-
- @Override
- public boolean equals(@Nullable Object obj) {
- if (obj instanceof SupplierFunction) {
- SupplierFunction that = (SupplierFunction) obj;
- return this.supplier.equals(that.supplier);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return supplier.hashCode();
- }
-
- @Override
- public String toString() {
- return "Functions.forSupplier(" + supplier + ")";
- }
-
- private static final long serialVersionUID = 0;
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Joiner.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Joiner.java
deleted file mode 100644
index df78e3bb13fb..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Joiner.java
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
- * Copyright (C) 2008 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.IOException;
-import java.util.AbstractList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * An object which joins pieces of text (specified as an array, {@link Iterable}, varargs or even a
- * {@link Map}) with a separator. It either appends the results to an {@link Appendable} or returns
- * them as a {@link String}. Example: {@code
- *
- * Joiner joiner = Joiner.on("; ").skipNulls();
- * . . .
- * return joiner.join("Harry", null, "Ron", "Hermione");}
- *
- * This returns the string {@code "Harry; Ron; Hermione"}. Note that all input elements are
- * converted to strings using {@link Object#toString()} before being appended.
- *
- *
If neither {@link #skipNulls()} nor {@link #useForNull(String)} is specified, the joining
- * methods will throw {@link NullPointerException} if any given element is null.
- *
- *
Warning: joiner instances are always immutable ; a configuration method such as {@code
- * useForNull} has no effect on the instance it is invoked on! You must store and use the new joiner
- * instance returned by the method. This makes joiners thread-safe, and safe to store as {@code
- * static final} constants.
{@code
- *
- * // Bad! Do not do this!
- * Joiner joiner = Joiner.on(',');
- * joiner.skipNulls(); // does nothing!
- * return joiner.join("wrong", null, "wrong");}
- *
- * See the Guava User Guide article on {@code Joiner} .
- *
- * @author Kevin Bourrillion
- * @since 2.0
- */
-@GwtCompatible
-public class Joiner {
- /**
- * Returns a joiner which automatically places {@code separator} between consecutive elements.
- */
- @CheckReturnValue
- public static Joiner on(String separator) {
- return new Joiner(separator);
- }
-
- /**
- * Returns a joiner which automatically places {@code separator} between consecutive elements.
- */
- @CheckReturnValue
- public static Joiner on(char separator) {
- return new Joiner(String.valueOf(separator));
- }
-
- private final String separator;
-
- private Joiner(String separator) {
- this.separator = checkNotNull(separator);
- }
-
- private Joiner(Joiner prototype) {
- this.separator = prototype.separator;
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code appendable}.
- */
- public A appendTo(A appendable, Iterable parts) throws IOException {
- return appendTo(appendable, parts.iterator());
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code appendable}.
- *
- * @since 11.0
- */
- public A appendTo(A appendable, Iterator parts) throws IOException {
- checkNotNull(appendable);
- if (parts.hasNext()) {
- appendable.append(toString(parts.next()));
- while (parts.hasNext()) {
- appendable.append(separator);
- appendable.append(toString(parts.next()));
- }
- }
- return appendable;
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code appendable}.
- */
- public final A appendTo(A appendable, Object[] parts) throws IOException {
- return appendTo(appendable, Arrays.asList(parts));
- }
-
- /**
- * Appends to {@code appendable} the string representation of each of the remaining arguments.
- */
- public final A appendTo(
- A appendable, @Nullable Object first, @Nullable Object second, Object... rest)
- throws IOException {
- return appendTo(appendable, iterable(first, second, rest));
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code builder}. Identical to {@link #appendTo(Appendable,
- * Iterable)}, except that it does not throw {@link IOException}.
- */
- public final StringBuilder appendTo(StringBuilder builder, Iterable parts) {
- return appendTo(builder, parts.iterator());
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code builder}. Identical to {@link #appendTo(Appendable,
- * Iterable)}, except that it does not throw {@link IOException}.
- *
- * @since 11.0
- */
- public final StringBuilder appendTo(StringBuilder builder, Iterator parts) {
- try {
- appendTo((Appendable) builder, parts);
- } catch (IOException impossible) {
- throw new AssertionError(impossible);
- }
- return builder;
- }
-
- /**
- * Appends the string representation of each of {@code parts}, using the previously configured
- * separator between each, to {@code builder}. Identical to {@link #appendTo(Appendable,
- * Iterable)}, except that it does not throw {@link IOException}.
- */
- public final StringBuilder appendTo(StringBuilder builder, Object[] parts) {
- return appendTo(builder, Arrays.asList(parts));
- }
-
- /**
- * Appends to {@code builder} the string representation of each of the remaining arguments.
- * Identical to {@link #appendTo(Appendable, Object, Object, Object...)}, except that it does not
- * throw {@link IOException}.
- */
- public final StringBuilder appendTo(
- StringBuilder builder, @Nullable Object first, @Nullable Object second, Object... rest) {
- return appendTo(builder, iterable(first, second, rest));
- }
-
- /**
- * Returns a string containing the string representation of each of {@code parts}, using the
- * previously configured separator between each.
- */
- @CheckReturnValue
- public final String join(Iterable parts) {
- return join(parts.iterator());
- }
-
- /**
- * Returns a string containing the string representation of each of {@code parts}, using the
- * previously configured separator between each.
- *
- * @since 11.0
- */
- @CheckReturnValue
- public final String join(Iterator parts) {
- return appendTo(new StringBuilder(), parts).toString();
- }
-
- /**
- * Returns a string containing the string representation of each of {@code parts}, using the
- * previously configured separator between each.
- */
- @CheckReturnValue
- public final String join(Object[] parts) {
- return join(Arrays.asList(parts));
- }
-
- /**
- * Returns a string containing the string representation of each argument, using the previously
- * configured separator between each.
- */
- @CheckReturnValue
- public final String join(@Nullable Object first, @Nullable Object second, Object... rest) {
- return join(iterable(first, second, rest));
- }
-
- /**
- * Returns a joiner with the same behavior as this one, except automatically substituting {@code
- * nullText} for any provided null elements.
- */
- @CheckReturnValue
- public Joiner useForNull(final String nullText) {
- checkNotNull(nullText);
- return new Joiner(this) {
- @Override
- CharSequence toString(@Nullable Object part) {
- return (part == null) ? nullText : Joiner.this.toString(part);
- }
-
- @Override
- public Joiner useForNull(String nullText) {
- throw new UnsupportedOperationException("already specified useForNull");
- }
-
- @Override
- public Joiner skipNulls() {
- throw new UnsupportedOperationException("already specified useForNull");
- }
- };
- }
-
- /**
- * Returns a joiner with the same behavior as this joiner, except automatically skipping over any
- * provided null elements.
- */
- @CheckReturnValue
- public Joiner skipNulls() {
- return new Joiner(this) {
- @Override
- public A appendTo(A appendable, Iterator parts) throws IOException {
- checkNotNull(appendable, "appendable");
- checkNotNull(parts, "parts");
- while (parts.hasNext()) {
- Object part = parts.next();
- if (part != null) {
- appendable.append(Joiner.this.toString(part));
- break;
- }
- }
- while (parts.hasNext()) {
- Object part = parts.next();
- if (part != null) {
- appendable.append(separator);
- appendable.append(Joiner.this.toString(part));
- }
- }
- return appendable;
- }
-
- @Override
- public Joiner useForNull(String nullText) {
- throw new UnsupportedOperationException("already specified skipNulls");
- }
-
- @Override
- public MapJoiner withKeyValueSeparator(String kvs) {
- throw new UnsupportedOperationException("can't use .skipNulls() with maps");
- }
- };
- }
-
- /**
- * Returns a {@code MapJoiner} using the given key-value separator, and the same configuration as
- * this {@code Joiner} otherwise.
- */
- @CheckReturnValue
- public MapJoiner withKeyValueSeparator(String keyValueSeparator) {
- return new MapJoiner(this, keyValueSeparator);
- }
-
- /**
- * An object that joins map entries in the same manner as {@code Joiner} joins iterables and
- * arrays. Like {@code Joiner}, it is thread-safe and immutable.
- *
- * In addition to operating on {@code Map} instances, {@code MapJoiner} can operate on {@code
- * Multimap} entries in two distinct modes:
- *
- *
- * To output a separate entry for each key-value pair, pass {@code multimap.entries()} to a
- * {@code MapJoiner} method that accepts entries as input, and receive output of the form
- * {@code key1=A&key1=B&key2=C}.
- * To output a single entry for each key, pass {@code multimap.asMap()} to a {@code MapJoiner}
- * method that accepts a map as input, and receive output of the form {@code
- * key1=[A, B]&key2=C}.
- *
- *
- * @since 2.0
- */
- public static final class MapJoiner {
- private final Joiner joiner;
- private final String keyValueSeparator;
-
- private MapJoiner(Joiner joiner, String keyValueSeparator) {
- this.joiner = joiner; // only "this" is ever passed, so don't checkNotNull
- this.keyValueSeparator = checkNotNull(keyValueSeparator);
- }
-
- /**
- * Appends the string representation of each entry of {@code map}, using the previously
- * configured separator and key-value separator, to {@code appendable}.
- */
- public A appendTo(A appendable, Map map) throws IOException {
- return appendTo(appendable, map.entrySet());
- }
-
- /**
- * Appends the string representation of each entry of {@code map}, using the previously
- * configured separator and key-value separator, to {@code builder}. Identical to {@link
- * #appendTo(Appendable, Map)}, except that it does not throw {@link IOException}.
- */
- public StringBuilder appendTo(StringBuilder builder, Map map) {
- return appendTo(builder, map.entrySet());
- }
-
- /**
- * Returns a string containing the string representation of each entry of {@code map}, using the
- * previously configured separator and key-value separator.
- */
- @CheckReturnValue
- public String join(Map map) {
- return join(map.entrySet());
- }
-
- /**
- * Appends the string representation of each entry in {@code entries}, using the previously
- * configured separator and key-value separator, to {@code appendable}.
- *
- * @since 10.0
- */
- @Beta
- public A appendTo(A appendable, Iterable> entries)
- throws IOException {
- return appendTo(appendable, entries.iterator());
- }
-
- /**
- * Appends the string representation of each entry in {@code entries}, using the previously
- * configured separator and key-value separator, to {@code appendable}.
- *
- * @since 11.0
- */
- @Beta
- public A appendTo(A appendable, Iterator> parts)
- throws IOException {
- checkNotNull(appendable);
- if (parts.hasNext()) {
- Entry entry = parts.next();
- appendable.append(joiner.toString(entry.getKey()));
- appendable.append(keyValueSeparator);
- appendable.append(joiner.toString(entry.getValue()));
- while (parts.hasNext()) {
- appendable.append(joiner.separator);
- Entry e = parts.next();
- appendable.append(joiner.toString(e.getKey()));
- appendable.append(keyValueSeparator);
- appendable.append(joiner.toString(e.getValue()));
- }
- }
- return appendable;
- }
-
- /**
- * Appends the string representation of each entry in {@code entries}, using the previously
- * configured separator and key-value separator, to {@code builder}. Identical to {@link
- * #appendTo(Appendable, Iterable)}, except that it does not throw {@link IOException}.
- *
- * @since 10.0
- */
- @Beta
- public StringBuilder appendTo(StringBuilder builder, Iterable> entries) {
- return appendTo(builder, entries.iterator());
- }
-
- /**
- * Appends the string representation of each entry in {@code entries}, using the previously
- * configured separator and key-value separator, to {@code builder}. Identical to {@link
- * #appendTo(Appendable, Iterable)}, except that it does not throw {@link IOException}.
- *
- * @since 11.0
- */
- @Beta
- public StringBuilder appendTo(StringBuilder builder, Iterator> entries) {
- try {
- appendTo((Appendable) builder, entries);
- } catch (IOException impossible) {
- throw new AssertionError(impossible);
- }
- return builder;
- }
-
- /**
- * Returns a string containing the string representation of each entry in {@code entries}, using
- * the previously configured separator and key-value separator.
- *
- * @since 10.0
- */
- @Beta
- @CheckReturnValue
- public String join(Iterable> entries) {
- return join(entries.iterator());
- }
-
- /**
- * Returns a string containing the string representation of each entry in {@code entries}, using
- * the previously configured separator and key-value separator.
- *
- * @since 11.0
- */
- @Beta
- @CheckReturnValue
- public String join(Iterator> entries) {
- return appendTo(new StringBuilder(), entries).toString();
- }
-
- /**
- * Returns a map joiner with the same behavior as this one, except automatically substituting
- * {@code nullText} for any provided null keys or values.
- */
- @CheckReturnValue
- public MapJoiner useForNull(String nullText) {
- return new MapJoiner(joiner.useForNull(nullText), keyValueSeparator);
- }
- }
-
- CharSequence toString(Object part) {
- checkNotNull(part); // checkNotNull for GWT (do not optimize).
- return (part instanceof CharSequence) ? (CharSequence) part : part.toString();
- }
-
- private static Iterable iterable(
- final Object first, final Object second, final Object[] rest) {
- checkNotNull(rest);
- return new AbstractList() {
- @Override
- public int size() {
- return rest.length + 2;
- }
-
- @Override
- public Object get(int index) {
- switch (index) {
- case 0:
- return first;
- case 1:
- return second;
- default:
- return rest[index - 2];
- }
- }
- };
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/MoreObjects.java b/thirdparty/google-guava/src/main/java/com/google/common/base/MoreObjects.java
deleted file mode 100644
index f87a89222380..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/MoreObjects.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- * Copyright (C) 2014 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.util.Arrays;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Helper functions that operate on any {@code Object}, and are not already provided in
- * {@link java.util.Objects}.
- *
- * See the Guava User Guide on writing
- * {@code Object} methods with {@code MoreObjects} .
- *
- * @author Laurence Gonsalves
- * @since 18.0 (since 2.0 as {@code Objects})
- */
-@GwtCompatible
-public final class MoreObjects {
- /**
- * Returns the first of two given parameters that is not {@code null}, if either is, or otherwise
- * throws a {@link NullPointerException}.
- *
- *
Note: if {@code first} is represented as an {@link Optional}, this can be
- * accomplished with {@link Optional#or(Object) first.or(second)}. That approach also allows for
- * lazy evaluation of the fallback instance, using {@link Optional#or(Supplier)
- * first.or(supplier)}.
- *
- * @return {@code first} if it is non-null; otherwise {@code second} if it is non-null
- * @throws NullPointerException if both {@code first} and {@code second} are null
- * @since 18.0 (since 3.0 as {@code Objects.firstNonNull()}).
- */
- @CheckReturnValue
- public static T firstNonNull(@Nullable T first, @Nullable T second) {
- return first != null ? first : checkNotNull(second);
- }
-
- /**
- * Creates an instance of {@link ToStringHelper}.
- *
- * This is helpful for implementing {@link Object#toString()}.
- * Specification by example:
{@code
- * // Returns "ClassName{}"
- * MoreObjects.toStringHelper(this)
- * .toString();
- *
- * // Returns "ClassName{x=1}"
- * MoreObjects.toStringHelper(this)
- * .add("x", 1)
- * .toString();
- *
- * // Returns "MyObject{x=1}"
- * MoreObjects.toStringHelper("MyObject")
- * .add("x", 1)
- * .toString();
- *
- * // Returns "ClassName{x=1, y=foo}"
- * MoreObjects.toStringHelper(this)
- * .add("x", 1)
- * .add("y", "foo")
- * .toString();
- *
- * // Returns "ClassName{x=1}"
- * MoreObjects.toStringHelper(this)
- * .omitNullValues()
- * .add("x", 1)
- * .add("y", null)
- * .toString();
- * }}
- *
- * Note that in GWT, class names are often obfuscated.
- *
- * @param self the object to generate the string for (typically {@code this}), used only for its
- * class name
- * @since 18.0 (since 2.0 as {@code Objects.toStringHelper()}).
- */
- @CheckReturnValue
- public static ToStringHelper toStringHelper(Object self) {
- return new ToStringHelper(self.getClass().getSimpleName());
- }
-
- /**
- * Creates an instance of {@link ToStringHelper} in the same manner as {@link
- * #toStringHelper(Object)}, but using the simple name of {@code clazz} instead of using an
- * instance's {@link Object#getClass()}.
- *
- *
Note that in GWT, class names are often obfuscated.
- *
- * @param clazz the {@link Class} of the instance
- * @since 18.0 (since 7.0 as {@code Objects.toStringHelper()}).
- */
- @CheckReturnValue
- public static ToStringHelper toStringHelper(Class clazz) {
- return new ToStringHelper(clazz.getSimpleName());
- }
-
- /**
- * Creates an instance of {@link ToStringHelper} in the same manner as {@link
- * #toStringHelper(Object)}, but using {@code className} instead of using an instance's {@link
- * Object#getClass()}.
- *
- * @param className the name of the instance type
- * @since 18.0 (since 7.0 as {@code Objects.toStringHelper()}).
- */
- @CheckReturnValue
- public static ToStringHelper toStringHelper(String className) {
- return new ToStringHelper(className);
- }
-
- /**
- * Support class for {@link MoreObjects#toStringHelper}.
- *
- * @author Jason Lee
- * @since 18.0 (since 2.0 as {@code Objects.ToStringHelper}).
- */
- public static final class ToStringHelper {
- private final String className;
- private ValueHolder holderHead = new ValueHolder();
- private ValueHolder holderTail = holderHead;
- private boolean omitNullValues = false;
-
- /**
- * Use {@link MoreObjects#toStringHelper(Object)} to create an instance.
- */
- private ToStringHelper(String className) {
- this.className = checkNotNull(className);
- }
-
- /**
- * Configures the {@link ToStringHelper} so {@link #toString()} will ignore
- * properties with null value. The order of calling this method, relative
- * to the {@code add()}/{@code addValue()} methods, is not significant.
- *
- * @since 18.0 (since 12.0 as {@code Objects.ToStringHelper.omitNullValues()}).
- */
- public ToStringHelper omitNullValues() {
- omitNullValues = true;
- return this;
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format. If {@code value} is {@code null}, the string {@code "null"}
- * is used, unless {@link #omitNullValues()} is called, in which case this
- * name/value pair will not be added.
- */
- public ToStringHelper add(String name, @Nullable Object value) {
- return addHolder(name, value);
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, boolean value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, char value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, double value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, float value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, int value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.add()}).
- */
- public ToStringHelper add(String name, long value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, Object)} instead
- * and give value a readable name.
- */
- public ToStringHelper addValue(@Nullable Object value) {
- return addHolder(value);
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, boolean)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(boolean value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, char)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(char value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, double)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(double value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, float)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(float value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, int)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(int value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, long)} instead
- * and give value a readable name.
- *
- * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
- */
- public ToStringHelper addValue(long value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Returns a string in the format specified by
- * {@link MoreObjects#toStringHelper(Object)}.
- *
- *
After calling this method, you can keep adding more properties to later
- * call toString() again and get a more complete representation of the
- * same object; but properties cannot be removed, so this only allows
- * limited reuse of the helper instance. The helper allows duplication of
- * properties (multiple name/value pairs with the same name can be added).
- */
- @CheckReturnValue
- @Override
- public String toString() {
- // create a copy to keep it consistent in case value changes
- boolean omitNullValuesSnapshot = omitNullValues;
- String nextSeparator = "";
- StringBuilder builder = new StringBuilder(32).append(className).append('{');
- for (ValueHolder valueHolder = holderHead.next;
- valueHolder != null;
- valueHolder = valueHolder.next) {
- Object value = valueHolder.value;
- if (!omitNullValuesSnapshot || value != null) {
- builder.append(nextSeparator);
- nextSeparator = ", ";
-
- if (valueHolder.name != null) {
- builder.append(valueHolder.name).append('=');
- }
- if (value != null && value.getClass().isArray()) {
- Object[] objectArray = {value};
- String arrayString = Arrays.deepToString(objectArray);
- builder.append(arrayString.substring(1, arrayString.length() - 1));
- } else {
- builder.append(value);
- }
- }
- }
- return builder.append('}').toString();
- }
-
- private ValueHolder addHolder() {
- ValueHolder valueHolder = new ValueHolder();
- holderTail = holderTail.next = valueHolder;
- return valueHolder;
- }
-
- private ToStringHelper addHolder(@Nullable Object value) {
- ValueHolder valueHolder = addHolder();
- valueHolder.value = value;
- return this;
- }
-
- private ToStringHelper addHolder(String name, @Nullable Object value) {
- ValueHolder valueHolder = addHolder();
- valueHolder.value = value;
- valueHolder.name = checkNotNull(name);
- return this;
- }
-
- private static final class ValueHolder {
- String name;
- Object value;
- ValueHolder next;
- }
- }
-
- private MoreObjects() {}
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Objects.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Objects.java
deleted file mode 100644
index 62817dacdffa..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Objects.java
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.util.Arrays;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Helper functions that can operate on any {@code Object}.
- *
- *
See the Guava User Guide on writing
- * {@code Object} methods with {@code Objects} .
- *
- * @author Laurence Gonsalves
- * @since 2.0
- */
-@GwtCompatible
-public final class Objects {
- private Objects() {}
-
- /**
- * Determines whether two possibly-null objects are equal. Returns:
- *
- *
- * {@code true} if {@code a} and {@code b} are both null.
- * {@code true} if {@code a} and {@code b} are both non-null and they are
- * equal according to {@link Object#equals(Object)}.
- * {@code false} in all other situations.
- *
- *
- * This assumes that any non-null objects passed to this function conform
- * to the {@code equals()} contract.
- *
- *
Note for Java 7 and later: This method should be treated as
- * deprecated; use {@link java.util.Objects#equals} instead.
- */
- @CheckReturnValue
- public static boolean equal(@Nullable Object a, @Nullable Object b) {
- return a == b || (a != null && a.equals(b));
- }
-
- /**
- * Generates a hash code for multiple values. The hash code is generated by
- * calling {@link Arrays#hashCode(Object[])}. Note that array arguments to
- * this method, with the exception of a single Object array, do not get any
- * special handling; their hash codes are based on identity and not contents.
- *
- *
This is useful for implementing {@link Object#hashCode()}. For example,
- * in an object that has three properties, {@code x}, {@code y}, and
- * {@code z}, one could write:
- *
{@code
- * public int hashCode() {
- * return Objects.hashCode(getX(), getY(), getZ());
- * }}
- *
- * Warning: When a single object is supplied, the returned hash code
- * does not equal the hash code of that object.
- *
- *
Note for Java 7 and later: This method should be treated as
- * deprecated; use {@link java.util.Objects#hash} instead.
- */
- @CheckReturnValue
- public static int hashCode(@Nullable Object... objects) {
- return Arrays.hashCode(objects);
- }
-
- /**
- * Creates an instance of {@link ToStringHelper}.
- *
- *
This is helpful for implementing {@link Object#toString()}.
- * Specification by example:
{@code
- * // Returns "ClassName{}"
- * Objects.toStringHelper(this)
- * .toString();
- *
- * // Returns "ClassName{x=1}"
- * Objects.toStringHelper(this)
- * .add("x", 1)
- * .toString();
- *
- * // Returns "MyObject{x=1}"
- * Objects.toStringHelper("MyObject")
- * .add("x", 1)
- * .toString();
- *
- * // Returns "ClassName{x=1, y=foo}"
- * Objects.toStringHelper(this)
- * .add("x", 1)
- * .add("y", "foo")
- * .toString();
- *
- * // Returns "ClassName{x=1}"
- * Objects.toStringHelper(this)
- * .omitNullValues()
- * .add("x", 1)
- * .add("y", null)
- * .toString();
- * }}
- *
- * Note that in GWT, class names are often obfuscated.
- *
- * @param self the object to generate the string for (typically {@code this}),
- * used only for its class name
- * @since 2.0
- * @deprecated Use {@link MoreObjects#toStringHelper(Object)} instead. This
- * method is scheduled for removal in June 2016.
- */
- @CheckReturnValue
- @Deprecated
- public static ToStringHelper toStringHelper(Object self) {
- return new ToStringHelper(self.getClass().getSimpleName());
- }
-
- /**
- * Creates an instance of {@link ToStringHelper} in the same manner as
- * {@link Objects#toStringHelper(Object)}, but using the name of {@code clazz}
- * instead of using an instance's {@link Object#getClass()}.
- *
- *
Note that in GWT, class names are often obfuscated.
- *
- * @param clazz the {@link Class} of the instance
- * @since 7.0 (source-compatible since 2.0)
- * @deprecated Use {@link MoreObjects#toStringHelper(Class)} instead. This
- * method is scheduled for removal in June 2016.
- */
- @CheckReturnValue
- @Deprecated
- public static ToStringHelper toStringHelper(Class clazz) {
- return new ToStringHelper(clazz.getSimpleName());
- }
-
- /**
- * Creates an instance of {@link ToStringHelper} in the same manner as
- * {@link Objects#toStringHelper(Object)}, but using {@code className} instead
- * of using an instance's {@link Object#getClass()}.
- *
- * @param className the name of the instance type
- * @since 7.0 (source-compatible since 2.0)
- * @deprecated Use {@link MoreObjects#toStringHelper(String)} instead. This
- * method is scheduled for removal in June 2016.
- */
- @CheckReturnValue
- @Deprecated
- public static ToStringHelper toStringHelper(String className) {
- return new ToStringHelper(className);
- }
-
- /**
- * Returns the first of two given parameters that is not {@code null}, if
- * either is, or otherwise throws a {@link NullPointerException}.
- *
- *
Note: if {@code first} is represented as an {@link Optional},
- * this can be accomplished with
- * {@linkplain Optional#or(Object) first.or(second)}.
- * That approach also allows for lazy evaluation of the fallback instance,
- * using {@linkplain Optional#or(Supplier) first.or(Supplier)}.
- *
- * @return {@code first} if {@code first} is not {@code null}, or
- * {@code second} if {@code first} is {@code null} and {@code second} is
- * not {@code null}
- * @throws NullPointerException if both {@code first} and {@code second} were
- * {@code null}
- * @since 3.0
- * @deprecated Use {@link MoreObjects#firstNonNull} instead. This method is
- * scheduled for removal in June 2016.
- */
- @CheckReturnValue
- @Deprecated
- public static T firstNonNull(@Nullable T first, @Nullable T second) {
- return MoreObjects.firstNonNull(first, second);
- }
-
- /**
- * Support class for {@link Objects#toStringHelper}.
- *
- * @author Jason Lee
- * @since 2.0
- * @deprecated Use {@link MoreObjects.ToStringHelper} instead. This class is
- * scheduled for removal in June 2016.
- */
- @Deprecated
- public static final class ToStringHelper {
- private final String className;
- private ValueHolder holderHead = new ValueHolder();
- private ValueHolder holderTail = holderHead;
- private boolean omitNullValues = false;
-
- /**
- * Use {@link Objects#toStringHelper(Object)} to create an instance.
- */
- private ToStringHelper(String className) {
- this.className = checkNotNull(className);
- }
-
- /**
- * Configures the {@link ToStringHelper} so {@link #toString()} will ignore
- * properties with null value. The order of calling this method, relative
- * to the {@code add()}/{@code addValue()} methods, is not significant.
- *
- * @since 12.0
- */
- public ToStringHelper omitNullValues() {
- omitNullValues = true;
- return this;
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format. If {@code value} is {@code null}, the string {@code "null"}
- * is used, unless {@link #omitNullValues()} is called, in which case this
- * name/value pair will not be added.
- */
- public ToStringHelper add(String name, @Nullable Object value) {
- return addHolder(name, value);
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, boolean value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, char value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, double value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, float value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, int value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds a name/value pair to the formatted output in {@code name=value}
- * format.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper add(String name, long value) {
- return addHolder(name, String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- * It is strongly encouraged to use {@link #add(String, Object)} instead
- * and give value a readable name.
- */
- public ToStringHelper addValue(@Nullable Object value) {
- return addHolder(value);
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, boolean)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(boolean value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, char)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(char value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, double)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(double value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, float)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(float value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, int)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(int value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Adds an unnamed value to the formatted output.
- *
- *
It is strongly encouraged to use {@link #add(String, long)} instead
- * and give value a readable name.
- *
- * @since 11.0 (source-compatible since 2.0)
- */
- public ToStringHelper addValue(long value) {
- return addHolder(String.valueOf(value));
- }
-
- /**
- * Returns a string in the format specified by {@link
- * Objects#toStringHelper(Object)}.
- *
- *
After calling this method, you can keep adding more properties to later
- * call toString() again and get a more complete representation of the
- * same object; but properties cannot be removed, so this only allows
- * limited reuse of the helper instance. The helper allows duplication of
- * properties (multiple name/value pairs with the same name can be added).
- */
- @Override
- public String toString() {
- // create a copy to keep it consistent in case value changes
- boolean omitNullValuesSnapshot = omitNullValues;
- String nextSeparator = "";
- StringBuilder builder = new StringBuilder(32).append(className).append('{');
- for (ValueHolder valueHolder = holderHead.next;
- valueHolder != null;
- valueHolder = valueHolder.next) {
- if (!omitNullValuesSnapshot || valueHolder.value != null) {
- builder.append(nextSeparator);
- nextSeparator = ", ";
-
- if (valueHolder.name != null) {
- builder.append(valueHolder.name).append('=');
- }
- builder.append(valueHolder.value);
- }
- }
- return builder.append('}').toString();
- }
-
- private ValueHolder addHolder() {
- ValueHolder valueHolder = new ValueHolder();
- holderTail = holderTail.next = valueHolder;
- return valueHolder;
- }
-
- private ToStringHelper addHolder(@Nullable Object value) {
- ValueHolder valueHolder = addHolder();
- valueHolder.value = value;
- return this;
- }
-
- private ToStringHelper addHolder(String name, @Nullable Object value) {
- ValueHolder valueHolder = addHolder();
- valueHolder.value = value;
- valueHolder.name = checkNotNull(name);
- return this;
- }
-
- private static final class ValueHolder {
- String name;
- Object value;
- ValueHolder next;
- }
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Optional.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Optional.java
deleted file mode 100644
index 6c4724b75d03..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Optional.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-import java.util.Iterator;
-import java.util.Set;
-
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * An immutable object that may contain a non-null reference to another object. Each
- * instance of this type either contains a non-null reference, or contains nothing (in
- * which case we say that the reference is "absent"); it is never said to "contain {@code
- * null}".
- *
- *
A non-null {@code Optional} reference can be used as a replacement for a nullable
- * {@code T} reference. It allows you to represent "a {@code T} that must be present" and
- * a "a {@code T} that might be absent" as two distinct types in your program, which can
- * aid clarity.
- *
- * Some uses of this class include
- *
- *
- * As a method return type, as an alternative to returning {@code null} to indicate
- * that no value was available
- * To distinguish between "unknown" (for example, not present in a map) and "known to
- * have no value" (present in the map, with value {@code Optional.absent()})
- * To wrap nullable references for storage in a collection that does not support
- * {@code null} (though there are
- *
- * several other approaches to this that should be considered first)
- *
- *
- * A common alternative to using this class is to find or create a suitable
- * null object for the
- * type in question.
- *
- *
This class is not intended as a direct analogue of any existing "option" or "maybe"
- * construct from other programming environments, though it may bear some similarities.
- *
- *
Comparison to {@code java.util.Optional} (JDK 8 and higher): A new {@code Optional}
- * class was added for Java 8. The two classes are extremely similar, but incompatible (they cannot
- * share a common supertype). All known differences are listed either here or with the
- * relevant methods below.
- *
- *
- * This class is serializable; {@code java.util.Optional} is not.
- * {@code java.util.Optional} has the additional methods {@code ifPresent}, {@code filter},
- * {@code flatMap}, and {@code orElseThrow}.
- * {@code java.util} offers the primitive-specialized versions {@code OptionalInt}, {@code
- * OptionalLong} and {@code OptionalDouble}, the use of which is recommended; Guava does not
- * have these.
- *
- *
- * There are no plans to deprecate this class in the foreseeable future. However, we do
- * gently recommend that you prefer the new, standard Java class whenever possible.
- *
- *
See the Guava User Guide article on
- * using {@code Optional} .
- *
- * @param the type of instance that can be contained. {@code Optional} is naturally
- * covariant on this type, so it is safe to cast an {@code Optional} to {@code
- * Optional} for any supertype {@code S} of {@code T}.
- * @author Kurt Alfred Kluever
- * @author Kevin Bourrillion
- * @since 10.0
- */
-@CheckReturnValue
-@GwtCompatible(serializable = true)
-public abstract class Optional implements Serializable {
- /**
- * Returns an {@code Optional} instance with no contained reference.
- *
- * Comparison to {@code java.util.Optional}: this method is equivalent to Java 8's
- * {@code Optional.empty}.
- */
- public static Optional absent() {
- return Absent.withType();
- }
-
- /**
- * Returns an {@code Optional} instance containing the given non-null reference. To have {@code
- * null} treated as {@link #absent}, use {@link #fromNullable} instead.
- *
- * Comparison to {@code java.util.Optional}: no differences.
- *
- * @throws NullPointerException if {@code reference} is null
- */
- public static Optional of(T reference) {
- return new Present(checkNotNull(reference));
- }
-
- /**
- * If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
- * reference; otherwise returns {@link Optional#absent}.
- *
- * Comparison to {@code java.util.Optional}: this method is equivalent to Java 8's
- * {@code Optional.ofNullable}.
- */
- public static Optional fromNullable(@Nullable T nullableReference) {
- return (nullableReference == null)
- ? Optional.absent()
- : new Present(nullableReference);
- }
-
- Optional() {}
-
- /**
- * Returns {@code true} if this holder contains a (non-null) instance.
- *
- * Comparison to {@code java.util.Optional}: no differences.
- */
- public abstract boolean isPresent();
-
- /**
- * Returns the contained instance, which must be present. If the instance might be
- * absent, use {@link #or(Object)} or {@link #orNull} instead.
- *
- *
Comparison to {@code java.util.Optional}: when the value is absent, this method
- * throws {@link IllegalStateException}, whereas the Java 8 counterpart throws {@link
- * NoSuchElementException}.
- *
- * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns
- * {@code false}); depending on this specific exception type (over the more general
- * {@link RuntimeException}) is discouraged
- */
- public abstract T get();
-
- /**
- * Returns the contained instance if it is present; {@code defaultValue} otherwise. If
- * no default value should be required because the instance is known to be present, use
- * {@link #get()} instead. For a default value of {@code null}, use {@link #orNull}.
- *
- *
Note about generics: The signature {@code public T or(T defaultValue)} is overly
- * restrictive. However, the ideal signature, {@code public S or(S)}, is not legal
- * Java. As a result, some sensible operations involving subtypes are compile errors:
- * {@code
- *
- * Optional optionalInt = getSomeOptionalInt();
- * Number value = optionalInt.or(0.5); // error
- *
- * FluentIterable numbers = getSomeNumbers();
- * Optional first = numbers.first();
- * Number value = first.or(0.5); // error}
- *
- *
As a workaround, it is always safe to cast an {@code Optional} to {@code
- * Optional}. Casting either of the above example {@code Optional} instances to {@code
- * Optional} (where {@code Number} is the desired output type) solves the problem:
- * {@code
- *
- * Optional optionalInt = (Optional) getSomeOptionalInt();
- * Number value = optionalInt.or(0.5); // fine
- *
- * FluentIterable numbers = getSomeNumbers();
- * Optional first = (Optional) numbers.first();
- * Number value = first.or(0.5); // fine}
- *
- * Comparison to {@code java.util.Optional}: this method is similar to Java 8's
- * {@code Optional.orElse}, but will not accept {@code null} as a {@code defaultValue} ({@link
- * #orNull} must be used instead). As a result, the value returned by this method is guaranteed
- * non-null, which is not the case for the {@code java.util} equivalent.
- */
- public abstract T or(T defaultValue);
-
- /**
- * Returns this {@code Optional} if it has a value present; {@code secondChoice}
- * otherwise.
- *
- *
Comparison to {@code java.util.Optional}: this method has no equivalent in Java 8's
- * {@code Optional} class; write {@code thisOptional.isPresent() ? thisOptional : secondChoice}
- * instead.
- */
- public abstract Optional or(Optional secondChoice);
-
- /**
- * Returns the contained instance if it is present; {@code supplier.get()} otherwise.
- *
- * Comparison to {@code java.util.Optional}: this method is similar to Java 8's
- * {@code Optional.orElseGet}, except when {@code supplier} returns {@code null}. In this case
- * this method throws an exception, whereas the Java 8 method returns the {@code null} to the
- * caller.
- *
- * @throws NullPointerException if this optional's value is absent and the supplier returns
- * {@code null}
- */
- @Beta
- public abstract T or(Supplier supplier);
-
- /**
- * Returns the contained instance if it is present; {@code null} otherwise. If the
- * instance is known to be present, use {@link #get()} instead.
- *
- *
Comparison to {@code java.util.Optional}: this method is equivalent to Java 8's
- * {@code Optional.orElse(null)}.
- */
- @Nullable
- public abstract T orNull();
-
- /**
- * Returns an immutable singleton {@link Set} whose only element is the contained instance
- * if it is present; an empty immutable {@link Set} otherwise.
- *
- *
Comparison to {@code java.util.Optional}: this method has no equivalent in Java 8's
- * {@code Optional} class. However, this common usage:
{@code
- *
- * for (Foo foo : possibleFoo.asSet()) {
- * doSomethingWith(foo);
- * }}
- *
- * ... can be replaced with: {@code
- *
- * possibleFoo.ifPresent(foo -> doSomethingWith(foo));}
- *
- * @since 11.0
- */
- public abstract Set asSet();
-
- /**
- * If the instance is present, it is transformed with the given {@link Function}; otherwise,
- * {@link Optional#absent} is returned.
- *
- * Comparison to {@code java.util.Optional}: this method is similar to Java 8's
- * {@code Optional.map}, except when {@code function} returns {@code null}. In this case this
- * method throws an exception, whereas the Java 8 method returns {@code Optional.absent()}.
- *
- * @throws NullPointerException if the function returns {@code null}
- * @since 12.0
- */
- public abstract Optional transform(Function function);
-
- /**
- * Returns {@code true} if {@code object} is an {@code Optional} instance, and either
- * the contained references are {@linkplain Object#equals equal} to each other or both
- * are absent. Note that {@code Optional} instances of differing parameterized types can
- * be equal.
- *
- * Comparison to {@code java.util.Optional}: no differences.
- */
- @Override
- public abstract boolean equals(@Nullable Object object);
-
- /**
- * Returns a hash code for this instance.
- *
- *
Comparison to {@code java.util.Optional}: this class leaves the specific choice of
- * hash code unspecified, unlike the Java 8 equivalent.
- */
- @Override
- public abstract int hashCode();
-
- /**
- * Returns a string representation for this instance.
- *
- *
Comparison to {@code java.util.Optional}: this class leaves the specific string
- * representation unspecified, unlike the Java 8 equivalent.
- */
- @Override
- public abstract String toString();
-
- /**
- * Returns the value of each present instance from the supplied {@code optionals}, in order,
- * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
- * evaluated lazily.
- *
- *
Comparison to {@code java.util.Optional}: this method has no equivalent in Java 8's
- * {@code Optional} class; use
- * {@code optionals.stream().filter(Optional::isPresent).map(Optional::get)} instead.
- *
- * @since 11.0 (generics widened in 13.0)
- */
- @Beta
- public static Iterable presentInstances(
- final Iterable> optionals) {
- checkNotNull(optionals);
- return new Iterable() {
- @Override
- public Iterator iterator() {
- return new AbstractIterator() {
- private final Iterator> iterator =
- checkNotNull(optionals.iterator());
-
- @Override
- protected T computeNext() {
- while (iterator.hasNext()) {
- Optional optional = iterator.next();
- if (optional.isPresent()) {
- return optional.get();
- }
- }
- return endOfData();
- }
- };
- }
- };
- }
-
- private static final long serialVersionUID = 0;
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/PairwiseEquivalence.java b/thirdparty/google-guava/src/main/java/com/google/common/base/PairwiseEquivalence.java
deleted file mode 100644
index d409d2451b72..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/PairwiseEquivalence.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2011 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.io.Serializable;
-import java.util.Iterator;
-
-import javax.annotation.Nullable;
-
-@GwtCompatible(serializable = true)
-final class PairwiseEquivalence extends Equivalence> implements Serializable {
-
- final Equivalence elementEquivalence;
-
- PairwiseEquivalence(Equivalence elementEquivalence) {
- this.elementEquivalence = Preconditions.checkNotNull(elementEquivalence);
- }
-
- @Override
- protected boolean doEquivalent(Iterable iterableA, Iterable iterableB) {
- Iterator iteratorA = iterableA.iterator();
- Iterator iteratorB = iterableB.iterator();
-
- while (iteratorA.hasNext() && iteratorB.hasNext()) {
- if (!elementEquivalence.equivalent(iteratorA.next(), iteratorB.next())) {
- return false;
- }
- }
-
- return !iteratorA.hasNext() && !iteratorB.hasNext();
- }
-
- @Override
- protected int doHash(Iterable iterable) {
- int hash = 78721;
- for (T element : iterable) {
- hash = hash * 24943 + elementEquivalence.hash(element);
- }
- return hash;
- }
-
- @Override
- public boolean equals(@Nullable Object object) {
- if (object instanceof PairwiseEquivalence) {
- PairwiseEquivalence that = (PairwiseEquivalence) object;
- return this.elementEquivalence.equals(that.elementEquivalence);
- }
-
- return false;
- }
-
- @Override
- public int hashCode() {
- return elementEquivalence.hashCode() ^ 0x46a3eb07;
- }
-
- @Override
- public String toString() {
- return elementEquivalence + ".pairwise()";
- }
-
- private static final long serialVersionUID = 1;
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Platform.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Platform.java
deleted file mode 100644
index 8debd9199b04..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Platform.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2009 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.GwtCompatible;
-
-import java.lang.ref.WeakReference;
-
-/**
- * Methods factored out so that they can be emulated differently in GWT.
- *
- * @author Jesse Wilson
- */
-@GwtCompatible(emulated = true)
-final class Platform {
- private Platform() {}
-
- /** Calls {@link System#nanoTime()}. */
- static long systemNanoTime() {
- return System.nanoTime();
- }
-
- static CharMatcher precomputeCharMatcher(CharMatcher matcher) {
- return matcher.precomputedInternal();
- }
-
- static > Optional getEnumIfPresent(Class enumClass, String value) {
- WeakReference> ref = Enums.getEnumConstants(enumClass).get(value);
- return ref == null
- ? Optional.absent()
- : Optional.of(enumClass.cast(ref.get()));
- }
-}
diff --git a/thirdparty/google-guava/src/main/java/com/google/common/base/Preconditions.java b/thirdparty/google-guava/src/main/java/com/google/common/base/Preconditions.java
deleted file mode 100644
index a27205fc43c6..000000000000
--- a/thirdparty/google-guava/src/main/java/com/google/common/base/Preconditions.java
+++ /dev/null
@@ -1,440 +0,0 @@
-/*
- * Copyright (C) 2007 The Guava Authors
- *
- * 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 com.google.common.base;
-
-import com.google.common.annotations.GwtCompatible;
-
-import javax.annotation.Nullable;
-
-/**
- * Static convenience methods that help a method or constructor check whether it was invoked
- * correctly (whether its preconditions have been met). These methods generally accept a
- * {@code boolean} expression which is expected to be {@code true} (or in the case of {@code
- * checkNotNull}, an object reference which is expected to be non-null). When {@code false} (or
- * {@code null}) is passed instead, the {@code Preconditions} method throws an unchecked exception,
- * which helps the calling method communicate to its caller that that caller has made
- * a mistake. Example: {@code
- *
- * /**
- * * Returns the positive square root of the given value.
- * *
- * * @throws IllegalArgumentException if the value is negative
- * *}{@code /
- * public static double sqrt(double value) {
- * Preconditions.checkArgument(value >= 0.0, "negative value: %s", value);
- * // calculate the square root
- * }
- *
- * void exampleBadCaller() {
- * double d = sqrt(-1.0);
- * }}
- *
- * In this example, {@code checkArgument} throws an {@code IllegalArgumentException} to indicate
- * that {@code exampleBadCaller} made an error in its call to {@code sqrt}.
- *
- * Warning about performance
- *
- * The goal of this class is to improve readability of code, but in some circumstances this may
- * come at a significant performance cost. Remember that parameter values for message construction
- * must all be computed eagerly, and autoboxing and varargs array creation may happen as well, even
- * when the precondition check then succeeds (as it should almost always do in production). In some
- * circumstances these wasted CPU cycles and allocations can add up to a real problem.
- * Performance-sensitive precondition checks can always be converted to the customary form:
- *
{@code
- *
- * if (value < 0.0) {
- * throw new IllegalArgumentException("negative value: " + value);
- * }}
- *
- * Other types of preconditions
- *
- * Not every type of precondition failure is supported by these methods. Continue to throw
- * standard JDK exceptions such as {@link java.util.NoSuchElementException} or {@link
- * UnsupportedOperationException} in the situations they are intended for.
- *
- *
Non-preconditions
- *
- * It is of course possible to use the methods of this class to check for invalid conditions
- * which are not the caller's fault . Doing so is not recommended because it is
- * misleading to future readers of the code and of stack traces. See
- * Conditional
- * failures explained in the Guava User Guide for more advice.
- *
- *
{@code java.util.Objects.requireNonNull()}
- *
- * Projects which use {@code com.google.common} should generally avoid the use of {@link
- * java.util.Objects#requireNonNull(Object)}. Instead, use whichever of {@link
- * #checkNotNull(Object)} or {@link Verify#verifyNotNull(Object)} is appropriate to the situation.
- * (The same goes for the message-accepting overloads.)
- *
- *
Only {@code %s} is supported
- *
- * In {@code Preconditions} error message template strings, only the {@code "%s"} specifier is
- * supported, not the full range of {@link java.util.Formatter} specifiers.
- *
- *
More information
- *
- * See the Guava User Guide on
- * using {@code
- * Preconditions} .
- *
- * @author Kevin Bourrillion
- * @since 2.0
- */
-@GwtCompatible
-public final class Preconditions {
- private Preconditions() {}
-
- /**
- * Ensures the truth of an expression involving one or more parameters to the calling method.
- *
- * @param expression a boolean expression
- * @throws IllegalArgumentException if {@code expression} is false
- */
- public static void checkArgument(boolean expression) {
- if (!expression) {
- throw new IllegalArgumentException();
- }
- }
-
- /**
- * Ensures the truth of an expression involving one or more parameters to the calling method.
- *
- * @param expression a boolean expression
- * @param errorMessage the exception message to use if the check fails; will be converted to a
- * string using {@link String#valueOf(Object)}
- * @throws IllegalArgumentException if {@code expression} is false
- */
- public static void checkArgument(boolean expression, @Nullable Object errorMessage) {
- if (!expression) {
- throw new IllegalArgumentException(String.valueOf(errorMessage));
- }
- }
-
- /**
- * Ensures the truth of an expression involving one or more parameters to the calling method.
- *
- * @param expression a boolean expression
- * @param errorMessageTemplate a template for the exception message should the check fail. The
- * message is formed by replacing each {@code %s} placeholder in the template with an
- * argument. These are matched by position - the first {@code %s} gets {@code
- * errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message
- * in square braces. Unmatched placeholders will be left as-is.
- * @param errorMessageArgs the arguments to be substituted into the message template. Arguments
- * are converted to strings using {@link String#valueOf(Object)}.
- * @throws IllegalArgumentException if {@code expression} is false
- * @throws NullPointerException if the check fails and either {@code errorMessageTemplate} or
- * {@code errorMessageArgs} is null (don't let this happen)
- */
- public static void checkArgument(
- boolean expression,
- @Nullable String errorMessageTemplate,
- @Nullable Object... errorMessageArgs) {
- if (!expression) {
- throw new IllegalArgumentException(format(errorMessageTemplate, errorMessageArgs));
- }
- }
-
- /**
- * Ensures the truth of an expression involving the state of the calling instance, but not
- * involving any parameters to the calling method.
- *
- * @param expression a boolean expression
- * @throws IllegalStateException if {@code expression} is false
- */
- public static void checkState(boolean expression) {
- if (!expression) {
- throw new IllegalStateException();
- }
- }
-
- /**
- * Ensures the truth of an expression involving the state of the calling instance, but not
- * involving any parameters to the calling method.
- *
- * @param expression a boolean expression
- * @param errorMessage the exception message to use if the check fails; will be converted to a
- * string using {@link String#valueOf(Object)}
- * @throws IllegalStateException if {@code expression} is false
- */
- public static void checkState(boolean expression, @Nullable Object errorMessage) {
- if (!expression) {
- throw new IllegalStateException(String.valueOf(errorMessage));
- }
- }
-
- /**
- * Ensures the truth of an expression involving the state of the calling instance, but not
- * involving any parameters to the calling method.
- *
- * @param expression a boolean expression
- * @param errorMessageTemplate a template for the exception message should the check fail. The
- * message is formed by replacing each {@code %s} placeholder in the template with an
- * argument. These are matched by position - the first {@code %s} gets {@code
- * errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message
- * in square braces. Unmatched placeholders will be left as-is.
- * @param errorMessageArgs the arguments to be substituted into the message template. Arguments
- * are converted to strings using {@link String#valueOf(Object)}.
- * @throws IllegalStateException if {@code expression} is false
- * @throws NullPointerException if the check fails and either {@code errorMessageTemplate} or
- * {@code errorMessageArgs} is null (don't let this happen)
- */
- public static void checkState(
- boolean expression,
- @Nullable String errorMessageTemplate,
- @Nullable Object... errorMessageArgs) {
- if (!expression) {
- throw new IllegalStateException(format(errorMessageTemplate, errorMessageArgs));
- }
- }
-
- /**
- * Ensures that an object reference passed as a parameter to the calling method is not null.
- *
- * @param reference an object reference
- * @return the non-null reference that was validated
- * @throws NullPointerException if {@code reference} is null
- */
- public static T checkNotNull(T reference) {
- if (reference == null) {
- throw new NullPointerException();
- }
- return reference;
- }
-
- /**
- * Ensures that an object reference passed as a parameter to the calling method is not null.
- *
- * @param reference an object reference
- * @param errorMessage the exception message to use if the check fails; will be converted to a
- * string using {@link String#valueOf(Object)}
- * @return the non-null reference that was validated
- * @throws NullPointerException if {@code reference} is null
- */
- public static