diff --git a/.idea/libraries/guice.xml b/.idea/libraries/guice.xml
deleted file mode 100644
index b62d5bb76e4..00000000000
--- a/.idea/libraries/guice.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/.idea/modules/elasticsearch.iml b/.idea/modules/elasticsearch.iml
index 69b50a8bef9..f50f981bca5 100644
--- a/.idea/modules/elasticsearch.iml
+++ b/.idea/modules/elasticsearch.iml
@@ -17,7 +17,6 @@
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 - uncomment when GWT support is official
+@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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/GwtIncompatible.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/GwtIncompatible.java
new file mode 100644
index 00000000000..dae25ba6fbf
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/GwtIncompatible.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.annotations;
+
+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 of types which
+ * are annotated as {@link GwtCompatible}.
+ *
+ * @author Charles Fry
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.METHOD)
+// @Documented - uncomment when GWT support is official
+@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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/VisibleForTesting.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/VisibleForTesting.java
new file mode 100644
index 00000000000..57f03301aa9
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/annotations/VisibleForTesting.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2006 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.annotations;
+
+/**
+ * An annotation that indicates that the visibility of a type or member has
+ * been relaxed to make the code testable.
+ *
+ * @author Johannes Henkel
+ */
+@GwtCompatible
+public @interface VisibleForTesting {}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizablePhantomReference.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizablePhantomReference.java
new file mode 100644
index 00000000000..d61f98f3efc
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizablePhantomReference.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import java.lang.ref.PhantomReference;
+
+/**
+ * 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
+ * java.lang.ref.ReferenceQueue}.
+ *
+ *
Unlike a normal phantom reference, this reference will be cleared
+ * automatically.
+ *
+ * @author Bob Lee
+ */
+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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReference.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReference.java
new file mode 100644
index 00000000000..0377bfb1e4c
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReference.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+/**
+ * Implemented by references that have code to run after garbage collection of
+ * their referents.
+ *
+ * @see FinalizableReferenceQueue
+ * @author Bob Lee
+ */
+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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReferenceQueue.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReferenceQueue.java
new file mode 100644
index 00000000000..19559ec2b91
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableReferenceQueue.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * 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.
+ *
+ * @author Bob Lee
+ */
+public class FinalizableReferenceQueue {
+
+ /*
+ * The Finalizer thread keeps a phantom reference to this object. When the
+ * client (ReferenceMap, for example) 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
+ = "org.elasticsearch.util.gcommon.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;
+
+ /**
+ * Whether or not the background thread started successfully.
+ */
+ final boolean threadStarted;
+
+ /**
+ * Constructs a new queue.
+ */
+ @SuppressWarnings("unchecked")
+ public FinalizableReferenceQueue() {
+ // We could start the finalizer lazily, but I'd rather it blow up early.
+ ReferenceQueue queue;
+ boolean threadStarted = false;
+ try {
+ queue = (ReferenceQueue) startFinalizer.invoke(null,
+ FinalizableReference.class, this);
+ threadStarted = true;
+ } catch (IllegalAccessException e) {
+ // Finalizer.startFinalizer() is public.
+ throw new AssertionError(e);
+ } catch (Throwable t) {
+ logger.log(Level.INFO, "Failed to start reference finalizer thread."
+ + " Reference cleanup will only occur when new references are"
+ + " created.", t);
+ queue = new ReferenceQueue();
+ }
+
+ this.queue = queue;
+ this.threadStarted = threadStarted;
+ }
+
+ /**
+ * 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
+ */
+ 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 {
+ public Class loadFinalizer() {
+ 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 Google Collections to your"
+ + " system class path.";
+
+ 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) {
+ return new URLClassLoader(new URL[] { base });
+ }
+ }
+
+ /**
+ * 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 {
+ 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, Object.class);
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError(e);
+ }
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableSoftReference.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableSoftReference.java
new file mode 100644
index 00000000000..d050ab544fa
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableSoftReference.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+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 java.lang.ref.ReferenceQueue}.
+ *
+ * @author Bob Lee
+ */
+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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableWeakReference.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableWeakReference.java
new file mode 100644
index 00000000000..30fcd6a737b
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/FinalizableWeakReference.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+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 java.lang.ref.ReferenceQueue}.
+ *
+ * @author Bob Lee
+ */
+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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Function.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Function.java
new file mode 100644
index 00000000000..0a7af2fc278
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Function.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+
+import javax.annotation.Nullable;
+
+/**
+ * A transformation from one object to another. For example, a
+ * {@code StringToIntegerFunction} may implement
+ * Function<String,Integer> and transform integers in
+ * {@code String} format to {@code Integer} format.
+ *
+ * The transformation on the source object does not necessarily result in
+ * an object of a different type. For example, a
+ * {@code FarenheitToCelsiusFunction} may implement
+ * Function<Float,Float>.
+ *
+ *
Implementations which may cause side effects upon evaluation are strongly
+ * encouraged to state this fact clearly in their API documentation.
+ *
+ * @param the type of the function input
+ * @param the type of the function output
+ * @author Kevin Bourrillion
+ * @author Scott Bonneau
+ */
+@GwtCompatible
+public interface Function {
+
+ /**
+ * Applies the function to an object of type {@code F}, resulting in an object
+ * of type {@code T}. Note that types {@code F} and {@code T} may or may not
+ * be the same.
+ *
+ * @param from the source object
+ * @return the resulting object
+ */
+ T apply(@Nullable F from);
+
+ /**
+ * Indicates whether some other object is equal to this {@code Function}.
+ * This method can return {@code true} only if the specified object is
+ * also a {@code Function} and, for every input object {@code o}, it returns
+ * exactly the same value. Thus, {@code function1.equals(function2)} implies
+ * that either {@code function1.apply(o)} and {@code function2.apply(o)} are
+ * both null, or {@code function1.apply(o).equals(function2.apply(o))}.
+ *
+ * Note that it is always safe not to override
+ * {@link Object#equals}.
+ */
+ boolean equals(@Nullable Object obj);
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Functions.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Functions.java
new file mode 100644
index 00000000000..baa092b16f2
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Functions.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkArgument;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkNotNull;
+
+import java.io.Serializable;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Useful functions.
+ *
+ *
All methods returns serializable functions as long as they're given
+ * serializable parameters.
+ *
+ * @author Mike Bostock
+ * @author Vlad Patryshev
+ * @author Jared Levy
+ */
+@GwtCompatible
+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}.
+ */
+ public static Function toStringFunction() {
+ return ToStringFunction.INSTANCE;
+ }
+
+ // enum singleton pattern
+ private enum ToStringFunction implements Function {
+ INSTANCE;
+
+ public String apply(Object o) {
+ return o.toString();
+ }
+
+ @Override public String toString() {
+ return "toString";
+ }
+ }
+
+ /**
+ * Returns the identity function.
+ */
+ @SuppressWarnings("unchecked")
+ public static Function identity() {
+ return (Function) IdentityFunction.INSTANCE;
+ }
+
+ // enum singleton pattern
+ private enum IdentityFunction implements Function {
+ INSTANCE;
+
+ public Object apply(Object o) {
+ return o;
+ }
+
+ @Override public String toString() {
+ return "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.
+ */
+ 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);
+ }
+ public V apply(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(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 "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.
+ *
+ * @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, V defaultValue) {
+ this.map = checkNotNull(map);
+ this.defaultValue = defaultValue;
+ }
+ public V apply(K key) {
+ return map.containsKey(key) ? map.get(key) : defaultValue;
+ }
+ @Override public boolean equals(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() {
+ return "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}.
+ *
+ * @see
+ * function composition
+ *
+ * @param g the second function to apply
+ * @param f the first function to apply
+ * @return the composition of {@code f} and {@code g}
+ */
+ 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);
+ }
+ public C apply(A a) {
+ return g.apply(f.apply(a));
+ }
+ @Override public boolean equals(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() {
+ return g.toString() + "(" + f.toString() + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /**
+ * Creates a function that returns the same boolean output as the given
+ * predicate for all inputs.
+ */
+ 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);
+ }
+
+ public Boolean apply(T t) {
+ return predicate.apply(t);
+ }
+ @Override public boolean equals(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 "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;
+ }
+ public E apply(Object from) {
+ return value;
+ }
+ @Override public boolean equals(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 "constant(" + value + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Joiner.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Joiner.java
new file mode 100644
index 00000000000..ff47e1a08d5
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Joiner.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkNotNull;
+
+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.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.
+ *
+ * @author Kevin Bourrillion
+ */
+@GwtCompatible public class Joiner {
+ /**
+ * Returns a joiner which automatically places {@code separator} between
+ * consecutive elements.
+ */
+ public static Joiner on(String separator) {
+ return new Joiner(separator);
+ }
+
+ /**
+ * Returns a joiner which automatically places {@code separator} between
+ * consecutive elements.
+ */
+ 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 {
+ checkNotNull(appendable);
+ Iterator iterator = parts.iterator();
+ if (iterator.hasNext()) {
+ appendable.append(toString(iterator.next()));
+ while (iterator.hasNext()) {
+ appendable.append(separator);
+ appendable.append(toString(iterator.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)
+ {
+ 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.
+ */
+ public final String join(Iterable 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.
+ */
+ 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.
+ */
+ 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.
+ */
+ public Joiner useForNull(final String nullText) {
+ checkNotNull(nullText);
+ return new Joiner(this) {
+ @Override CharSequence toString(Object part) {
+ return (part == null) ? nullText : Joiner.this.toString(part);
+ }
+ @Override public Joiner useForNull(String nullText) {
+ checkNotNull(nullText); // weird, just to satisfy NullPointerTester!
+ // TODO: fix that?
+ 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.
+ */
+ public Joiner skipNulls() {
+ return new Joiner(this) {
+ @Override public A appendTo(
+ A appendable, Iterable parts) throws IOException {
+ checkNotNull(appendable, "appendable");
+ checkNotNull(parts, "parts");
+ Iterator iterator = parts.iterator();
+ while (iterator.hasNext()) {
+ Object part = iterator.next();
+ if (part != null) {
+ appendable.append(Joiner.this.toString(part));
+ break;
+ }
+ }
+ while (iterator.hasNext()) {
+ Object part = iterator.next();
+ if (part != null) {
+ appendable.append(separator);
+ appendable.append(Joiner.this.toString(part));
+ }
+ }
+ return appendable;
+ }
+ @Override public Joiner useForNull(String nullText) {
+ checkNotNull(nullText); // weird, just to satisfy NullPointerTester!
+ throw new UnsupportedOperationException("already specified skipNulls");
+ }
+ @Override public MapJoiner withKeyValueSeparator(String kvs) {
+ checkNotNull(kvs); // weird, just to satisfy NullPointerTester!
+ 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.
+ */
+ public MapJoiner withKeyValueSeparator(String keyValueSeparator) {
+ return new MapJoiner(this, checkNotNull(keyValueSeparator));
+ }
+
+ /**
+ * An object that joins map entries in the same manner as {@code Joiner} joins
+ * iterables and arrays.
+ */
+ public static class MapJoiner {
+ private Joiner joiner;
+ private String keyValueSeparator;
+
+ private MapJoiner(Joiner joiner, String keyValueSeparator) {
+ this.joiner = joiner;
+ this.keyValueSeparator = 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 {
+ checkNotNull(appendable);
+ Iterator> iterator = map.entrySet().iterator();
+ if (iterator.hasNext()) {
+ Entry entry = iterator.next();
+ appendable.append(joiner.toString(entry.getKey()));
+ appendable.append(keyValueSeparator);
+ appendable.append(joiner.toString(entry.getValue()));
+ while (iterator.hasNext()) {
+ appendable.append(joiner.separator);
+ Entry e = iterator.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 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) {
+ try {
+ appendTo((Appendable) builder, map);
+ } catch (IOException impossible) {
+ throw new AssertionError(impossible);
+ }
+ return builder;
+ }
+
+ /**
+ * Returns a string containing the string representation of each entry of
+ * {@code map}, using the previously configured separator and key-value
+ * separator.
+ */
+ public String join(Map map) {
+ return appendTo(new StringBuilder(), map).toString();
+ }
+
+ /**
+ * Returns a map joiner with the same behavior as this one, except
+ * automatically substituting {@code nullText} for any provided null keys or
+ * values.
+ */
+ public MapJoiner useForNull(String nullText) {
+ return new MapJoiner(joiner.useForNull(nullText), keyValueSeparator);
+ }
+ }
+
+ CharSequence toString(Object part) {
+ 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/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Objects.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Objects.java
new file mode 100644
index 00000000000..6135693030b
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Objects.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+
+import java.util.Arrays;
+
+import javax.annotation.Nullable;
+
+/**
+ * Helper functions that can operate on any {@code Object}.
+ *
+ * @author Laurence Gonsalves
+ */
+@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.
+ */
+ 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[])}.
+ *
+ *
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:
+ *
+ * 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.
+ */
+ public static int hashCode(Object... objects) {
+ return Arrays.hashCode(objects);
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Platform.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Platform.java
new file mode 100644
index 00000000000..30cb69e8c91
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Platform.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+
+/**
+ * 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 Class#isInstance(Object)}.
+ *
+ * This method is not supported in GWT yet.
+ */
+ static boolean isInstance(Class clazz, Object obj) {
+ return clazz.isInstance(obj);
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Preconditions.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Preconditions.java
new file mode 100644
index 00000000000..f72add517d9
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Preconditions.java
@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+import org.elasticsearch.util.gcommon.annotations.VisibleForTesting;
+
+import java.util.NoSuchElementException;
+
+/**
+ * Simple static methods to be called at the start of your own methods to verify
+ * correct arguments and state. This allows constructs such as
+ *
+ * if (count <= 0) {
+ * throw new IllegalArgumentException("must be positive: " + count);
+ * }
+ *
+ * to be replaced with the more compact
+ *
+ * checkArgument(count > 0, "must be positive: %s", count);
+ *
+ * Note that the sense of the expression is inverted; with {@code Preconditions}
+ * you declare what you expect to be true , just as you do with an
+ *
+ * {@code assert} or a JUnit {@code assertTrue} call.
+ *
+ * Warning: only the {@code "%s"} specifier is recognized as a
+ * placeholder in these messages, not the full range of {@link
+ * String#format(String, Object[])} specifiers.
+ *
+ *
Take care not to confuse precondition checking with other similar types
+ * of checks! Precondition exceptions -- including those provided here, but also
+ * {@link IndexOutOfBoundsException}, {@link NoSuchElementException}, {@link
+ * UnsupportedOperationException} and others -- are used to signal that the
+ * calling method has made an error. This tells the caller that it should
+ * not have invoked the method when it did, with the arguments it did, or
+ * perhaps ever. Postcondition or other invariant failures should not throw
+ * these types of exceptions.
+ *
+ * @author Kevin Bourrillion
+ */
+@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, 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,
+ String errorMessageTemplate, 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, 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,
+ String errorMessageTemplate, 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 T checkNotNull(T reference, Object errorMessage) {
+ if (reference == null) {
+ throw new NullPointerException(String.valueOf(errorMessage));
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling
+ * method is not null.
+ *
+ * @param reference an object reference
+ * @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)}.
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static T checkNotNull(T reference, String errorMessageTemplate,
+ Object... errorMessageArgs) {
+ if (reference == null) {
+ // If either of these parameters is null, the right thing happens anyway
+ throw new NullPointerException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid element in an array,
+ * list or string of size {@code size}. An element index may range from zero,
+ * inclusive, to {@code size}, exclusive.
+ *
+ * @param index a user-supplied index identifying an element of an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is not
+ * less than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkElementIndex(int index, int size) {
+ return checkElementIndex(index, size, "index");
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid element in an array,
+ * list or string of size {@code size}. An element index may range from zero,
+ * inclusive, to {@code size}, exclusive.
+ *
+ * @param index a user-supplied index identifying an element of an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @param desc the text to use to describe this index in an error message
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is not
+ * less than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkElementIndex(int index, int size, String desc) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (index < 0 || index >= size) {
+ throw new IndexOutOfBoundsException(badElementIndex(index, size, desc));
+ }
+ return index;
+ }
+
+ private static String badElementIndex(int index, int size, String desc) {
+ if (index < 0) {
+ return format("%s (%s) must not be negative", desc, index);
+ } else if (size < 0) {
+ throw new IllegalArgumentException("negative size: " + size);
+ } else { // index >= size
+ return format("%s (%s) must be less than size (%s)", desc, index, size);
+ }
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid position in an array,
+ * list or string of size {@code size}. A position index may range from zero
+ * to {@code size}, inclusive.
+ *
+ * @param index a user-supplied index identifying a position in an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is
+ * greater than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkPositionIndex(int index, int size) {
+ return checkPositionIndex(index, size, "index");
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid position in an array,
+ * list or string of size {@code size}. A position index may range from zero
+ * to {@code size}, inclusive.
+ *
+ * @param index a user-supplied index identifying a position in an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @param desc the text to use to describe this index in an error message
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is
+ * greater than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkPositionIndex(int index, int size, String desc) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (index < 0 || index > size) {
+ throw new IndexOutOfBoundsException(badPositionIndex(index, size, desc));
+ }
+ return index;
+ }
+
+ private static String badPositionIndex(int index, int size, String desc) {
+ if (index < 0) {
+ return format("%s (%s) must not be negative", desc, index);
+ } else if (size < 0) {
+ throw new IllegalArgumentException("negative size: " + size);
+ } else { // index > size
+ return format("%s (%s) must not be greater than size (%s)",
+ desc, index, size);
+ }
+ }
+
+ /**
+ * Ensures that {@code start} and {@code end} specify a valid positions
+ * in an array, list or string of size {@code size}, and are in order. A
+ * position index may range from zero to {@code size}, inclusive.
+ *
+ * @param start a user-supplied index identifying a starting position in an
+ * array, list or string
+ * @param end a user-supplied index identifying a ending position in an array,
+ * list or string
+ * @param size the size of that array, list or string
+ * @throws IndexOutOfBoundsException if either index is negative or is
+ * greater than {@code size}, or if {@code end} is less than {@code start}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static void checkPositionIndexes(int start, int end, int size) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (start < 0 || end < start || end > size) {
+ throw new IndexOutOfBoundsException(badPositionIndexes(start, end, size));
+ }
+ }
+
+ private static String badPositionIndexes(int start, int end, int size) {
+ if (start < 0 || start > size) {
+ return badPositionIndex(start, size, "start index");
+ }
+ if (end < 0 || end > size) {
+ return badPositionIndex(end, size, "end index");
+ }
+ // end < start
+ return format("end index (%s) must not be less than start index (%s)",
+ end, start);
+ }
+
+ /**
+ * Substitutes each {@code %s} in {@code template} with an argument. These
+ * are matched by position - the first {@code %s} gets {@code args[0]}, etc.
+ * If there are more arguments than placeholders, the unmatched arguments will
+ * be appended to the end of the formatted message in square braces.
+ *
+ * @param template a non-null string containing 0 or more {@code %s}
+ * placeholders.
+ * @param args the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}. Arguments can be null.
+ */
+ @VisibleForTesting static String format(String template, Object... args) {
+ // start substituting the arguments into the '%s' placeholders
+ StringBuilder builder = new StringBuilder(
+ template.length() + 16 * args.length);
+ int templateStart = 0;
+ int i = 0;
+ while (i < args.length) {
+ int placeholderStart = template.indexOf("%s", templateStart);
+ if (placeholderStart == -1) {
+ break;
+ }
+ builder.append(template.substring(templateStart, placeholderStart));
+ builder.append(args[i++]);
+ templateStart = placeholderStart + 2;
+ }
+ builder.append(template.substring(templateStart));
+
+ // if we run out of placeholders, append the extra args in square braces
+ if (i < args.length) {
+ builder.append(" [");
+ builder.append(args[i++]);
+ while (i < args.length) {
+ builder.append(", ");
+ builder.append(args[i++]);
+ }
+ builder.append("]");
+ }
+
+ return builder.toString();
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicate.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicate.java
new file mode 100644
index 00000000000..2e99ab79733
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicate.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+
+import javax.annotation.Nullable;
+
+/**
+ * Determines a true or false value for a given input. For example, a
+ * {@code RegexPredicate} might implement {@code Predicate}, and return
+ * {@code true} for any string that matches its given regular expression.
+ *
+ * Implementations which may cause side effects upon evaluation are strongly
+ * encouraged to state this fact clearly in their API documentation.
+ *
+ * @author Kevin Bourrillion
+ */
+@GwtCompatible
+public interface Predicate {
+
+ /*
+ * This interface does not extend Function because doing so would
+ * let predicates return null.
+ */
+
+ /**
+ * Applies this predicate to the given object.
+ *
+ * @param input the input that the predicate should act on
+ * @return the value of this predicate when applied to the input {@code t}
+ */
+ boolean apply(@Nullable T input);
+
+ /**
+ * Indicates whether some other object is equal to this {@code Predicate}.
+ * This method can return {@code true} only if the specified object is
+ * also a {@code Predicate} and, for every input object {@code input}, it
+ * returns exactly the same value. Thus, {@code predicate1.equals(predicate2)}
+ * implies that either {@code predicate1.apply(input)} and
+ * {@code predicate2.apply(input)} are both {@code true} or both
+ * {@code false}.
+ *
+ * Note that it is always safe not to override
+ * {@link Object#equals}.
+ */
+ boolean equals(@Nullable Object obj);
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicates.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicates.java
new file mode 100644
index 00000000000..506219e9bfb
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Predicates.java
@@ -0,0 +1,554 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+import org.elasticsearch.util.gcommon.annotations.GwtIncompatible;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkNotNull;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+/**
+ * Contains static factory methods for creating {@code Predicate} instances.
+ *
+ *
All methods returns serializable predicates as long as they're given
+ * serializable parameters.
+ *
+ * @author Kevin Bourrillion
+ */
+@GwtCompatible
+public final class Predicates {
+ private Predicates() {}
+
+ // TODO: considering having these implement a VisitablePredicate interface
+ // which specifies an accept(PredicateVisitor) method.
+
+ /**
+ * Returns a predicate that always evaluates to {@code true}.
+ */
+ @GwtCompatible(serializable = true)
+ @SuppressWarnings("unchecked")
+ public static Predicate alwaysTrue() {
+ return (Predicate) AlwaysTruePredicate.INSTANCE;
+ }
+
+ /**
+ * Returns a predicate that always evaluates to {@code false}.
+ */
+ @GwtCompatible(serializable = true)
+ @SuppressWarnings("unchecked")
+ public static Predicate alwaysFalse() {
+ return (Predicate) AlwaysFalsePredicate.INSTANCE;
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the object reference
+ * being tested is null.
+ */
+ @SuppressWarnings("unchecked")
+ public static Predicate isNull() {
+ return (Predicate) IsNullPredicate.INSTANCE;
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the object reference
+ * being tested is not null.
+ */
+ @SuppressWarnings("unchecked")
+ public static Predicate notNull() {
+ return (Predicate) NotNullPredicate.INSTANCE;
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the given predicate
+ * evaluates to {@code false}.
+ */
+ public static Predicate not(Predicate predicate) {
+ return new NotPredicate(predicate);
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if each of its
+ * components evaluates to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as a false
+ * predicate is found. It defensively copies the iterable passed in, so future
+ * changes to it won't alter the behavior of this predicate. If {@code
+ * components} is empty, the returned predicate will always evaluate to {@code
+ * true}.
+ */
+ public static Predicate and(
+ Iterable> components) {
+ return new AndPredicate(defensiveCopy(components));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if each of its
+ * components evaluates to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as a false
+ * predicate is found. It defensively copies the array passed in, so future
+ * changes to it won't alter the behavior of this predicate. If {@code
+ * components} is empty, the returned predicate will always evaluate to {@code
+ * true}.
+ */
+ public static Predicate and(Predicate... components) {
+ return new AndPredicate(defensiveCopy(components));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if both of its
+ * components evaluate to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as a false
+ * predicate is found.
+ */
+ public static Predicate and(Predicate first,
+ Predicate second) {
+ return new AndPredicate(Predicates.asList(
+ checkNotNull(first), checkNotNull(second)));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if any one of its
+ * components evaluates to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as as soon as a
+ * true predicate is found. It defensively copies the iterable passed in, so
+ * future changes to it won't alter the behavior of this predicate. If {@code
+ * components} is empty, the returned predicate will always evaluate to {@code
+ * false}.
+ */
+ public static Predicate or(
+ Iterable> components) {
+ return new OrPredicate(defensiveCopy(components));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if any one of its
+ * components evaluates to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as as soon as a
+ * true predicate is found. It defensively copies the array passed in, so
+ * future changes to it won't alter the behavior of this predicate. If {@code
+ * components} is empty, the returned predicate will always evaluate to {@code
+ * false}.
+ */
+ public static Predicate or(Predicate... components) {
+ return new OrPredicate(defensiveCopy(components));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if either of its
+ * components evaluates to {@code true}. The components are evaluated in
+ * order, and evaluation will be "short-circuited" as soon as as soon as a
+ * true predicate is found.
+ */
+ public static Predicate or(Predicate first,
+ Predicate second) {
+ return new OrPredicate(Predicates.asList(
+ checkNotNull(first), checkNotNull(second)));
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the object being
+ * tested {@code equals()} the given target or both are null.
+ */
+ public static Predicate equalTo(@Nullable T target) {
+ // TODO: Change signature to return Predicate.
+ return (target == null)
+ ? Predicates.isNull()
+ : new IsEqualToPredicate(target);
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the object being
+ * tested is an instance of the given class. If the object being tested
+ * is {@code null} this predicate evaluates to {@code false}.
+ *
+ * If you want to filter an {@code Iterable} to narrow its type, consider
+ * using {@link org.elasticsearch.util.gcommon.collect.Iterables#filter(Iterable, Class)}
+ * in preference.
+ */
+ @GwtIncompatible("Class.isInstance")
+ public static Predicate instanceOf(Class clazz) {
+ return new InstanceOfPredicate(clazz);
+ }
+
+ /**
+ * Returns a predicate that evaluates to {@code true} if the object reference
+ * being tested is a member of the given collection. It does not defensively
+ * copy the collection passed in, so future changes to it will alter the
+ * behavior of the predicate.
+ *
+ * This method can technically accept any Collection, but using a typed
+ * collection helps prevent bugs. This approach doesn't block any potential
+ * users since it is always possible to use {@code Predicates.in()}.
+ *
+ * @param target the collection that may contain the function input
+ */
+ public static Predicate in(Collection target) {
+ return new InPredicate(target);
+ }
+
+ /**
+ * Returns the composition of a function and a predicate. For every {@code x},
+ * the generated predicate returns {@code predicate(function(x))}.
+ *
+ * @return the composition of the provided function and predicate
+ */
+ public static Predicate compose(
+ Predicate predicate, Function function) {
+ return new CompositionPredicate(predicate, function);
+ }
+
+ /** @see Predicates#alwaysTrue() */
+ // Package private for GWT serialization.
+ enum AlwaysTruePredicate implements Predicate {
+ INSTANCE;
+
+ public boolean apply(Object o) {
+ return true;
+ }
+ @Override public String toString() {
+ return "AlwaysTrue";
+ }
+ }
+
+ /** @see Predicates#alwaysFalse() */
+ // Package private for GWT serialization.
+ enum AlwaysFalsePredicate implements Predicate {
+ INSTANCE;
+
+ public boolean apply(Object o) {
+ return false;
+ }
+ @Override public String toString() {
+ return "AlwaysFalse";
+ }
+ }
+
+ /** @see Predicates#not(Predicate) */
+ private static class NotPredicate
+ implements Predicate, Serializable {
+ private final Predicate predicate;
+
+ private NotPredicate(Predicate predicate) {
+ this.predicate = checkNotNull(predicate);
+ }
+ public boolean apply(T t) {
+ return !predicate.apply(t);
+ }
+ @Override public int hashCode() {
+ return ~predicate.hashCode(); /* Invert all bits. */
+ }
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof NotPredicate) {
+ NotPredicate that = (NotPredicate) obj;
+ return predicate.equals(that.predicate);
+ }
+ return false;
+ }
+ @Override public String toString() {
+ return "Not(" + predicate.toString() + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ private static final Joiner commaJoiner = Joiner.on(",");
+
+ /** @see Predicates#and(Iterable) */
+ private static class AndPredicate
+ implements Predicate, Serializable {
+ private final Iterable> components;
+
+ private AndPredicate(Iterable> components) {
+ this.components = components;
+ }
+ public boolean apply(T t) {
+ for (Predicate predicate : components) {
+ if (!predicate.apply(t)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ @Override public int hashCode() {
+ int result = -1; /* Start with all bits on. */
+ for (Predicate predicate : components) {
+ result &= predicate.hashCode();
+ }
+ return result;
+ }
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof AndPredicate) {
+ AndPredicate that = (AndPredicate) obj;
+ return iterableElementsEqual(components, that.components);
+ }
+ return false;
+ }
+ @Override public String toString() {
+ return "And(" + commaJoiner.join(components) + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /** @see Predicates#or(Iterable) */
+ private static class OrPredicate
+ implements Predicate, Serializable {
+ private final Iterable> components;
+
+ private OrPredicate(Iterable> components) {
+ this.components = components;
+ }
+ public boolean apply(T t) {
+ for (Predicate predicate : components) {
+ if (predicate.apply(t)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ @Override public int hashCode() {
+ int result = 0; /* Start with all bits off. */
+ for (Predicate predicate : components) {
+ result |= predicate.hashCode();
+ }
+ return result;
+ }
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof OrPredicate) {
+ OrPredicate that = (OrPredicate) obj;
+ return iterableElementsEqual(components, that.components);
+ }
+ return false;
+ }
+ @Override public String toString() {
+ return "Or(" + commaJoiner.join(components) + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /** @see Predicates#equalTo(Object) */
+ private static class IsEqualToPredicate
+ implements Predicate, Serializable {
+ private final T target;
+
+ private IsEqualToPredicate(T target) {
+ this.target = target;
+ }
+ public boolean apply(T t) {
+ return target.equals(t);
+ }
+ @Override public int hashCode() {
+ return target.hashCode();
+ }
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof IsEqualToPredicate) {
+ IsEqualToPredicate that = (IsEqualToPredicate) obj;
+ return target.equals(that.target);
+ }
+ return false;
+ }
+ @Override public String toString() {
+ return "IsEqualTo(" + target + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /** @see Predicates#instanceOf(Class) */
+ private static class InstanceOfPredicate
+ implements Predicate, Serializable {
+ private final Class clazz;
+
+ private InstanceOfPredicate(Class clazz) {
+ this.clazz = checkNotNull(clazz);
+ }
+ public boolean apply(Object o) {
+ return Platform.isInstance(clazz, o);
+ }
+ @Override public int hashCode() {
+ return clazz.hashCode();
+ }
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof InstanceOfPredicate) {
+ InstanceOfPredicate that = (InstanceOfPredicate) obj;
+ return clazz == that.clazz;
+ }
+ return false;
+ }
+ @Override public String toString() {
+ return "IsInstanceOf(" + clazz.getName() + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /** @see Predicates#isNull() */
+ // enum singleton pattern
+ private enum IsNullPredicate implements Predicate {
+ INSTANCE;
+
+ public boolean apply(Object o) {
+ return o == null;
+ }
+ @Override public String toString() {
+ return "IsNull";
+ }
+ }
+
+ /** @see Predicates#notNull() */
+ // enum singleton pattern
+ private enum NotNullPredicate implements Predicate {
+ INSTANCE;
+
+ public boolean apply(Object o) {
+ return o != null;
+ }
+ @Override public String toString() {
+ return "NotNull";
+ }
+ }
+
+ /** @see Predicates#in(Collection) */
+ private static class InPredicate
+ implements Predicate, Serializable {
+ private final Collection target;
+
+ private InPredicate(Collection target) {
+ this.target = checkNotNull(target);
+ }
+
+ public boolean apply(T t) {
+ try {
+ return target.contains(t);
+ } catch (NullPointerException e) {
+ return false;
+ } catch (ClassCastException e) {
+ return false;
+ }
+ }
+
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof InPredicate) {
+ InPredicate that = (InPredicate) obj;
+ return target.equals(that.target);
+ }
+ return false;
+ }
+
+ @Override public int hashCode() {
+ return target.hashCode();
+ }
+
+ @Override public String toString() {
+ return "In(" + target + ")";
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /** @see Predicates#compose(Predicate, Function) */
+ private static class CompositionPredicate
+ implements Predicate, Serializable {
+ final Predicate p;
+ final Function f;
+
+ private CompositionPredicate(Predicate p, Function f) {
+ this.p = checkNotNull(p);
+ this.f = checkNotNull(f);
+ }
+
+ public boolean apply(A a) {
+ return p.apply(f.apply(a));
+ }
+
+ @Override public boolean equals(Object obj) {
+ if (obj instanceof CompositionPredicate) {
+ CompositionPredicate that = (CompositionPredicate) obj;
+ return f.equals(that.f) && p.equals(that.p);
+ }
+ return false;
+ }
+
+ @Override public int hashCode() {
+ /*
+ * TODO: To leave the door open for future enhancement, this
+ * calculation should be coordinated with the hashCode() method of the
+ * corresponding composition method in Functions. To construct the
+ * composition:
+ * predicate(function2(function1(x)))
+ *
+ * There are two different ways of composing it:
+ * compose(predicate, compose(function2, function1))
+ * compose(compose(predicate, function2), function1)
+ *
+ * It would be nice if these could be equal.
+ */
+ return f.hashCode() ^ p.hashCode();
+ }
+
+ @Override public String toString() {
+ return p.toString() + "(" + f.toString() + ")";
+ }
+
+ private static final long serialVersionUID = 0;
+ }
+
+ /**
+ * Determines whether the two Iterables contain equal elements. More
+ * specifically, this method returns {@code true} if {@code iterable1} and
+ * {@code iterable2} contain the same number of elements and every element of
+ * {@code iterable1} is equal to the corresponding element of {@code
+ * iterable2}.
+ *
+ * This is not a general-purpose method; it assumes that the iterations
+ * contain no {@code null} elements.
+ */
+ private static boolean iterableElementsEqual(
+ Iterable iterable1, Iterable iterable2) {
+ Iterator iterator1 = iterable1.iterator();
+ Iterator iterator2 = iterable2.iterator();
+ while (iterator1.hasNext()) {
+ if (!iterator2.hasNext()) {
+ return false;
+ }
+ if (!iterator1.next().equals(iterator2.next())) {
+ return false;
+ }
+ }
+ return !iterator2.hasNext();
+ }
+
+ @SuppressWarnings("unchecked")
+ private static List> asList(
+ Predicate first, Predicate second) {
+ return Arrays.>asList(first, second);
+ }
+
+ private static List defensiveCopy(T... array) {
+ return defensiveCopy(Arrays.asList(array));
+ }
+
+ static List defensiveCopy(Iterable iterable) {
+ ArrayList list = new ArrayList();
+ for (T element : iterable) {
+ list.add(checkNotNull(element));
+ }
+ return list;
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Supplier.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Supplier.java
new file mode 100644
index 00000000000..9450e36bc55
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Supplier.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+
+/**
+ * A class that can supply objects of a single type. Semantically, this could
+ * be a factory, generator, builder, closure, or something else entirely. No
+ * guarantees are implied by this interface.
+ *
+ * @author Harry Heymann
+ */
+@GwtCompatible
+public interface Supplier {
+ /**
+ * Retrieves an instance of the appropriate type. The returned object may or
+ * may not be a new instance, depending on the implementation.
+ *
+ * @return an instance of the appropriate type
+ */
+ public T get();
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Suppliers.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Suppliers.java
new file mode 100644
index 00000000000..54f23945112
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/Suppliers.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base;
+
+import org.elasticsearch.util.gcommon.annotations.VisibleForTesting;
+
+import java.io.Serializable;
+
+import javax.annotation.Nullable;
+
+/**
+ * Useful suppliers.
+ *
+ * All methods return serializable suppliers as long as they're given
+ * serializable parameters.
+ *
+ * @author Laurence Gonsalves
+ * @author Harry Heymann
+ */
+public final class Suppliers {
+ private Suppliers() {}
+
+ /**
+ * Returns a new supplier which is the composition of the provided function
+ * and supplier. In other words, the new supplier's value will be computed by
+ * retrieving the value from {@code first}, and then applying
+ * {@code function} to that value. Note that the resulting supplier will not
+ * call {@code first} or invoke {@code function} until it is called.
+ */
+ public static Supplier compose(
+ Function function, Supplier first) {
+ Preconditions.checkNotNull(function);
+ Preconditions.checkNotNull(first);
+ return new SupplierComposition(function, first);
+ }
+
+ private static class SupplierComposition
+ implements Supplier, Serializable {
+ final Function function;
+ final Supplier first;
+
+ SupplierComposition(Function function,
+ Supplier first) {
+ this.function = function;
+ this.first = first;
+ }
+ public T get() {
+ return function.apply(first.get());
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /**
+ * Returns a supplier which caches the instance retrieved during the first
+ * call to {@code get()} and returns that value on subsequent calls to
+ * {@code get()}. See:
+ * memoization
+ *
+ * The returned supplier is thread-safe. The supplier's serialized form
+ * does not contain the cached value, which will be recalculated when {@code
+ * get()} is called on the reserialized instance.
+ */
+ public static Supplier memoize(Supplier delegate) {
+ return new MemoizingSupplier(Preconditions.checkNotNull(delegate));
+ }
+
+ @VisibleForTesting static class MemoizingSupplier
+ implements Supplier, Serializable {
+ final Supplier delegate;
+ transient boolean initialized;
+ transient T value;
+
+ MemoizingSupplier(Supplier delegate) {
+ this.delegate = delegate;
+ }
+
+ public synchronized T get() {
+ if (!initialized) {
+ value = delegate.get();
+ initialized = true;
+ }
+ return value;
+ }
+
+ private static final long serialVersionUID = 0;
+ }
+
+ /**
+ * Returns a supplier that always supplies {@code instance}.
+ */
+ public static Supplier ofInstance(@Nullable T instance) {
+ return new SupplierOfInstance(instance);
+ }
+
+ private static class SupplierOfInstance
+ implements Supplier, Serializable {
+ final T instance;
+
+ SupplierOfInstance(T instance) {
+ this.instance = instance;
+ }
+ public T get() {
+ return instance;
+ }
+ private static final long serialVersionUID = 0;
+ }
+
+ /**
+ * Returns a supplier whose {@code get()} method synchronizes on
+ * {@code delegate} before calling it, making it thread-safe.
+ */
+ public static Supplier synchronizedSupplier(Supplier delegate) {
+ return new ThreadSafeSupplier(Preconditions.checkNotNull(delegate));
+ }
+
+ private static class ThreadSafeSupplier
+ implements Supplier, Serializable {
+ final Supplier delegate;
+
+ ThreadSafeSupplier(Supplier delegate) {
+ this.delegate = delegate;
+ }
+ public T get() {
+ synchronized (delegate) {
+ return delegate.get();
+ }
+ }
+ private static final long serialVersionUID = 0;
+ }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/internal/Finalizer.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/internal/Finalizer.java
new file mode 100644
index 00000000000..11fca3ff7cd
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/internal/Finalizer.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.base.internal;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Thread that finalizes referents. All references should implement
+ * {@code com.google.common.base.FinalizableReference}.
+ *
+ * While this class is public, we consider it to be *internal* and not part
+ * of our published API. It is public so we can access it reflectively across
+ * class loaders in secure environments.
+ *
+ *
This class can't depend on other Google Collections code. If we were
+ * to load this class in the same class loader as the rest of
+ * Google Collections, this thread would keep an indirect strong reference
+ * to the class loader and prevent it from being garbage collected. This
+ * poses a problem for environments where you want to throw away the class
+ * loader. For example, dynamically reloading a web application or unloading
+ * an OSGi bundle.
+ *
+ *
{@code com.google.common.base.FinalizableReferenceQueue} loads this class
+ * in its own class loader. That way, this class doesn't prevent the main
+ * class loader from getting garbage collected, and this class can detect when
+ * the main class loader has been garbage collected and stop itself.
+ */
+public class Finalizer extends Thread {
+
+ private static final Logger logger
+ = Logger.getLogger(Finalizer.class.getName());
+
+ /** Name of FinalizableReference.class. */
+ private static final String FINALIZABLE_REFERENCE
+ = "org.elasticsearch.util.gcommon.base.FinalizableReference";
+
+ /**
+ * Starts the Finalizer thread. FinalizableReferenceQueue calls this method
+ * reflectively.
+ *
+ * @param finalizableReferenceClass FinalizableReference.class
+ * @param frq reference to instance of FinalizableReferenceQueue that started
+ * this thread
+ * @return ReferenceQueue which Finalizer will poll
+ */
+ public static ReferenceQueue startFinalizer(
+ Class finalizableReferenceClass, Object frq) {
+ /*
+ * We use FinalizableReference.class for two things:
+ *
+ * 1) To invoke FinalizableReference.finalizeReferent()
+ *
+ * 2) To detect when FinalizableReference's class loader has to be garbage
+ * collected, at which point, Finalizer can stop running
+ */
+ if (!finalizableReferenceClass.getName().equals(FINALIZABLE_REFERENCE)) {
+ throw new IllegalArgumentException(
+ "Expected " + FINALIZABLE_REFERENCE + ".");
+ }
+
+ Finalizer finalizer = new Finalizer(finalizableReferenceClass, frq);
+ finalizer.start();
+ return finalizer.queue;
+ }
+
+ private final WeakReference> finalizableReferenceClassReference;
+ private final PhantomReference frqReference;
+ private final ReferenceQueue queue = new ReferenceQueue();
+
+ private static final Field inheritableThreadLocals
+ = getInheritableThreadLocalsField();
+
+ /** Constructs a new finalizer thread. */
+ private Finalizer(Class finalizableReferenceClass, Object frq) {
+ super(Finalizer.class.getName());
+
+ this.finalizableReferenceClassReference
+ = new WeakReference>(finalizableReferenceClass);
+
+ // Keep track of the FRQ that started us so we know when to stop.
+ this.frqReference = new PhantomReference(frq, queue);
+
+ setDaemon(true);
+
+ try {
+ if (inheritableThreadLocals != null) {
+ inheritableThreadLocals.set(this, null);
+ }
+ } catch (Throwable t) {
+ logger.log(Level.INFO, "Failed to clear thread local values inherited"
+ + " by reference finalizer thread.", t);
+ }
+
+ // TODO: Priority?
+ }
+
+ /**
+ * Loops continuously, pulling references off the queue and cleaning them up.
+ */
+ @SuppressWarnings("InfiniteLoopStatement")
+ @Override
+ public void run() {
+ try {
+ while (true) {
+ try {
+ cleanUp(queue.remove());
+ } catch (InterruptedException e) { /* ignore */ }
+ }
+ } catch (ShutDown shutDown) { /* ignore */ }
+ }
+
+ /**
+ * Cleans up a single reference. Catches and logs all throwables.
+ */
+ private void cleanUp(Reference reference) throws ShutDown {
+ Method finalizeReferentMethod = getFinalizeReferentMethod();
+ do {
+ /*
+ * This is for the benefit of phantom references. Weak and soft
+ * references will have already been cleared by this point.
+ */
+ reference.clear();
+
+ if (reference == frqReference) {
+ /*
+ * The client no longer has a reference to the
+ * FinalizableReferenceQueue. We can stop.
+ */
+ throw new ShutDown();
+ }
+
+ try {
+ finalizeReferentMethod.invoke(reference);
+ } catch (Throwable t) {
+ logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
+ }
+
+ /*
+ * Loop as long as we have references available so as not to waste
+ * CPU looking up the Method over and over again.
+ */
+ } while ((reference = queue.poll()) != null);
+ }
+
+ /**
+ * Looks up FinalizableReference.finalizeReferent() method.
+ */
+ private Method getFinalizeReferentMethod() throws ShutDown {
+ Class finalizableReferenceClass
+ = finalizableReferenceClassReference.get();
+ if (finalizableReferenceClass == null) {
+ /*
+ * FinalizableReference's class loader was reclaimed. While there's a
+ * chance that other finalizable references could be enqueued
+ * subsequently (at which point the class loader would be resurrected
+ * by virtue of us having a strong reference to it), we should pretty
+ * much just shut down and make sure we don't keep it alive any longer
+ * than necessary.
+ */
+ throw new ShutDown();
+ }
+ try {
+ return finalizableReferenceClass.getMethod("finalizeReferent");
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static Field getInheritableThreadLocalsField() {
+ try {
+ Field inheritableThreadLocals
+ = Thread.class.getDeclaredField("inheritableThreadLocals");
+ inheritableThreadLocals.setAccessible(true);
+ return inheritableThreadLocals;
+ } catch (Throwable t) {
+ logger.log(Level.INFO, "Couldn't access Thread.inheritableThreadLocals."
+ + " Reference finalizer threads will inherit thread local"
+ + " values.");
+ return null;
+ }
+ }
+
+ /** Indicates that it's time to shut down the Finalizer. */
+ @SuppressWarnings("serial") // Never serialized or thrown out of this class.
+ private static class ShutDown extends Exception { }
+}
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/package-info.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/package-info.java
new file mode 100644
index 00000000000..f5faee65acc
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/base/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Miscellaneous common util classes and annotations.
+ */
+package org.elasticsearch.util.gcommon.base;
diff --git a/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/collect/AbstractBiMap.java b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/collect/AbstractBiMap.java
new file mode 100644
index 00000000000..0823e76c0a6
--- /dev/null
+++ b/modules/elasticsearch/src/main/java/org/elasticsearch/util/gcommon/collect/AbstractBiMap.java
@@ -0,0 +1,394 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.elasticsearch.util.gcommon.collect;
+
+import org.elasticsearch.util.gcommon.annotations.GwtCompatible;
+import org.elasticsearch.util.gcommon.base.Objects;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkArgument;
+import static org.elasticsearch.util.gcommon.base.Preconditions.checkState;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+/**
+ * A general-purpose bimap implementation using any two backing {@code Map}
+ * instances.
+ *
+ * Note that this class contains {@code equals()} calls that keep it from
+ * supporting {@code IdentityHashMap} backing maps.
+ *
+ * @author Kevin Bourrillion
+ * @author Mike Bostock
+ */
+@GwtCompatible
+abstract class AbstractBiMap extends ForwardingMap
+ implements BiMap, Serializable {
+
+ private transient Map delegate;
+ private transient AbstractBiMap inverse;
+
+ /** Package-private constructor for creating a map-backed bimap. */
+ AbstractBiMap(Map forward, Map backward) {
+ setDelegates(forward, backward);
+ }
+
+ /** Private constructor for inverse bimap. */
+ private AbstractBiMap(Map backward, AbstractBiMap forward) {
+ delegate = backward;
+ inverse = forward;
+ }
+
+ @Override protected Map delegate() {
+ return delegate;
+ }
+
+ /**
+ * Specifies the delegate maps going in each direction. Called by the
+ * constructor and by subclasses during deserialization.
+ */
+ void setDelegates(Map forward, Map backward) {
+ checkState(delegate == null);
+ checkState(inverse == null);
+ checkArgument(forward.isEmpty());
+ checkArgument(backward.isEmpty());
+ checkArgument(forward != backward);
+ delegate = forward;
+ inverse = new Inverse(backward, this);
+ }
+
+ void setInverse(AbstractBiMap inverse) {
+ this.inverse = inverse;
+ }
+
+ // Query Operations (optimizations)
+
+ @Override public boolean containsValue(Object value) {
+ return inverse.containsKey(value);
+ }
+
+ // Modification Operations
+
+ @Override public V put(K key, V value) {
+ return putInBothMaps(key, value, false);
+ }
+
+ public V forcePut(K key, V value) {
+ return putInBothMaps(key, value, true);
+ }
+
+ private V putInBothMaps(@Nullable K key, @Nullable V value, boolean force) {
+ boolean containedKey = containsKey(key);
+ if (containedKey && Objects.equal(value, get(key))) {
+ return value;
+ }
+ if (force) {
+ inverse().remove(value);
+ } else {
+ checkArgument(!containsValue(value), "value already present: %s", value);
+ }
+ V oldValue = delegate.put(key, value);
+ updateInverseMap(key, containedKey, oldValue, value);
+ return oldValue;
+ }
+
+ private void updateInverseMap(
+ K key, boolean containedKey, V oldValue, V newValue) {
+ if (containedKey) {
+ removeFromInverseMap(oldValue);
+ }
+ inverse.delegate.put(newValue, key);
+ }
+
+ @Override public V remove(Object key) {
+ return containsKey(key) ? removeFromBothMaps(key) : null;
+ }
+
+ private V removeFromBothMaps(Object key) {
+ V oldValue = delegate.remove(key);
+ removeFromInverseMap(oldValue);
+ return oldValue;
+ }
+
+ private void removeFromInverseMap(V oldValue) {
+ inverse.delegate.remove(oldValue);
+ }
+
+ // Bulk Operations
+
+ @Override public void putAll(Map map) {
+ for (Entry entry : map.entrySet()) {
+ put(entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override public void clear() {
+ delegate.clear();
+ inverse.delegate.clear();
+ }
+
+ // Views
+
+ public BiMap inverse() {
+ return inverse;
+ }
+
+ private transient Set keySet;
+
+ @Override public Set keySet() {
+ Set result = keySet;
+ return (result == null) ? keySet = new KeySet() : result;
+ }
+
+ private class KeySet extends ForwardingSet {
+ @Override protected Set delegate() {
+ return delegate.keySet();
+ }
+
+ @Override public void clear() {
+ AbstractBiMap.this.clear();
+ }
+
+ @Override public boolean remove(Object key) {
+ if (!contains(key)) {
+ return false;
+ }
+ removeFromBothMaps(key);
+ return true;
+ }
+
+ @Override public boolean removeAll(Collection keysToRemove) {
+ return Iterators.removeAll(iterator(), keysToRemove);
+ }
+
+ @Override public boolean retainAll(Collection keysToRetain) {
+ return Iterators.retainAll(iterator(), keysToRetain);
+ }
+
+ @Override public Iterator iterator() {
+ final Iterator> iterator = delegate.entrySet().iterator();
+ return new Iterator() {
+ Entry entry;
+
+ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+ public K next() {
+ entry = iterator.next();
+ return entry.getKey();
+ }
+ public void remove() {
+ checkState(entry != null);
+ V value = entry.getValue();
+ iterator.remove();
+ removeFromInverseMap(value);
+ }
+ };
+ }
+ }
+
+ private transient Set valueSet;
+
+ @Override public Set values() {
+ /*
+ * We can almost reuse the inverse's keySet, except we have to fix the
+ * iteration order so that it is consistent with the forward map.
+ */
+ Set result = valueSet;
+ return (result == null) ? valueSet = new ValueSet() : result;
+ }
+
+ private class ValueSet extends ForwardingSet {
+ final Set valuesDelegate = inverse.keySet();
+
+ @Override protected Set delegate() {
+ return valuesDelegate;
+ }
+
+ @Override public Iterator iterator() {
+ final Iterator iterator = delegate.values().iterator();
+ return new Iterator() {
+ V valueToRemove;
+
+ /*@Override*/ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ /*@Override*/ public V next() {
+ return valueToRemove = iterator.next();
+ }
+
+ /*@Override*/ public void remove() {
+ iterator.remove();
+ removeFromInverseMap(valueToRemove);
+ }
+ };
+ }
+
+ @Override public Object[] toArray() {
+ return ObjectArrays.toArrayImpl(this);
+ }
+
+ @Override public T[] toArray(T[] array) {
+ return ObjectArrays.toArrayImpl(this, array);
+ }
+
+ @Override public String toString() {
+ return Iterators.toString(iterator());
+ }
+ }
+
+ private transient Set> entrySet;
+
+ @Override public Set> entrySet() {
+ Set> result = entrySet;
+ return (result == null) ? entrySet = new EntrySet() : result;
+ }
+
+ private class EntrySet extends ForwardingSet> {
+ final Set> esDelegate = delegate.entrySet();
+
+ @Override protected Set> delegate() {
+ return esDelegate;
+ }
+
+ @Override public void clear() {
+ AbstractBiMap.this.clear();
+ }
+
+ @Override public boolean remove(Object object) {
+ if (!esDelegate.remove(object)) {
+ return false;
+ }
+ Entry entry = (Entry) object;
+ inverse.delegate.remove(entry.getValue());
+ return true;
+ }
+
+ @Override public Iterator> iterator() {
+ final Iterator> iterator = esDelegate.iterator();
+ return new Iterator>() {
+ Entry entry;
+
+ /*@Override*/ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ /*@Override*/ public Entry next() {
+ entry = iterator.next();
+ final Entry finalEntry = entry;
+
+ return new ForwardingMapEntry() {
+ @Override protected Entry delegate() {
+ return finalEntry;
+ }
+
+ @Override public V setValue(V value) {
+ // Preconditions keep the map and inverse consistent.
+ checkState(contains(this), "entry no longer in map");
+ // similar to putInBothMaps, but set via entry
+ if (Objects.equal(value, getValue())) {
+ return value;
+ }
+ checkArgument(!containsValue(value),
+ "value already present: %s", value);
+ V oldValue = finalEntry.setValue(value);
+ checkState(Objects.equal(value, get(getKey())),
+ "entry no longer in map");
+ updateInverseMap(getKey(), true, oldValue, value);
+ return oldValue;
+ }
+ };
+ }
+
+ /*@Override*/ public void remove() {
+ checkState(entry != null);
+ V value = entry.getValue();
+ iterator.remove();
+ removeFromInverseMap(value);
+ }
+ };
+ }
+
+ // See java.util.Collections.CheckedEntrySet for details on attacks.
+
+ @Override public Object[] toArray() {
+ return ObjectArrays.toArrayImpl(this);
+ }
+ @Override public T[] toArray(T[] array) {
+ return ObjectArrays.toArrayImpl(this, array);
+ }
+ @Override public boolean contains(Object o) {
+ return Maps.containsEntryImpl(delegate(), o);
+ }
+ @Override public boolean containsAll(Collection c) {
+ return Collections2.containsAll(this, c);
+ }
+ @Override public boolean removeAll(Collection c) {
+ return Iterators.removeAll(iterator(), c);
+ }
+ @Override public boolean retainAll(Collection c) {
+ return Iterators.retainAll(iterator(), c);
+ }
+ }
+
+ /** The inverse of any other {@code AbstractBiMap} subclass. */
+ private static class Inverse extends AbstractBiMap {
+ private Inverse(Map