+ * Returns {@code false} otherwise, including for {@code null} values or + * objects of different types. + *
+ * Note: {@code Tuple} instances are equal if the underlying values are
+ * equal, even if the types are different.
+ *
+ * @param o the object to compare to
+ * @return {@code true} if the given object is also a tuple and the two tuples
+ * have equal {@link #v1()} and {@link #v2()} values.
+ */
@Override
public boolean equals(Object o) {
if (this == o) return true;
@@ -74,6 +88,10 @@ public boolean equals(Object o) {
return true;
}
+ /**
+ * Returns the hash code value for this Tuple.
+ * @return the hash code value for this Tuple.
+ */
@Override
public int hashCode() {
int result = v1 != null ? v1.hashCode() : 0;
@@ -81,6 +99,10 @@ public int hashCode() {
return result;
}
+ /**
+ * Returns a string representation of a Tuple
+ * @return {@code "Tuple [v1=value1, v2=value2]"}
+ */
@Override
public String toString() {
return "Tuple [v1=" + v1 + ", v2=" + v2 + "]";
diff --git a/libs/common/src/main/java/org/opensearch/common/crypto/CryptoHandler.java b/libs/common/src/main/java/org/opensearch/common/crypto/CryptoHandler.java
new file mode 100644
index 0000000000000..9572b5b9054b2
--- /dev/null
+++ b/libs/common/src/main/java/org/opensearch/common/crypto/CryptoHandler.java
@@ -0,0 +1,118 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.crypto;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.io.InputStreamContainer;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Crypto provider abstractions for encryption and decryption of data. Allows registering multiple providers
+ * for defining different ways of encrypting or decrypting data.
+ *
+ * @param
+ * Implements t1ha1;
+ * a fast portable hash function with reasonable quality for checksums, hash tables, and thin fingerprinting.
+ *
+ *
+ * To overcome language and performance limitations, this implementation differs slightly from the
+ * reference implementation in C++,
+ * so the returned values may vary before JDK 18.
+ *
+ *
+ * Intended for little-endian systems but returns the same result on big-endian, albeit marginally slower.
+ *
+ * @opensearch.internal
+ */
+@InternalApi
+public final class T1ha1 {
+ private static final long SEED = System.nanoTime();
+ private static final Mux64 MUX_64_IMPL = fastestMux64Impl();
+
+ private static final VarHandle LONG_HANDLE = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+ private static final VarHandle INT_HANDLE = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+ private static final VarHandle SHORT_HANDLE = MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.LITTLE_ENDIAN);
+
+ // "Magic" primes:
+ private static final long p0 = 0xEC99BF0D8372CAABL;
+ private static final long p1 = 0x82434FE90EDCEF39L;
+ private static final long p2 = 0xD4F06DB99D67BE4BL;
+ private static final long p3 = 0xBD9CACC22C6E9571L;
+ private static final long p4 = 0x9C06FAF4D023E3ABL;
+ private static final long p5 = 0xC060724A8424F345L;
+ private static final long p6 = 0xCB5AF53AE3AAAC31L;
+
+ // Rotations:
+ private static final int s0 = 41;
+ private static final int s1 = 17;
+ private static final int s2 = 31;
+
+ /**
+ * No public constructor.
+ */
+ private T1ha1() {}
+
+ /**
+ * Returns the hash code for the specified range of the given {@code byte} array.
+ * @param input the input byte array
+ * @param offset the starting offset
+ * @param length the length of the range
+ * @return hash code
+ */
+ public static long hash(byte[] input, int offset, int length) {
+ return hash(input, offset, length, SEED);
+ }
+
+ /**
+ * Returns the hash code for the specified range of the given {@code byte} array.
+ * @param input the input byte array
+ * @param offset the starting offset
+ * @param length the length of the range
+ * @param seed customized seed
+ * @return hash code
+ */
+ public static long hash(byte[] input, int offset, int length, long seed) {
+ long a = seed;
+ long b = length;
+
+ if (length > 32) {
+ long c = rotateRight(length, s1) + seed;
+ long d = length ^ rotateRight(seed, s1);
+
+ do {
+ long w0 = fetch64(input, offset);
+ long w1 = fetch64(input, offset + 8);
+ long w2 = fetch64(input, offset + 16);
+ long w3 = fetch64(input, offset + 24);
+
+ long d02 = w0 ^ rotateRight(w2 + d, s1);
+ long c13 = w1 ^ rotateRight(w3 + c, s1);
+ c += a ^ rotateRight(w0, s0);
+ d -= b ^ rotateRight(w1, s2);
+ a ^= p1 * (d02 + w3);
+ b ^= p0 * (c13 + w2);
+
+ offset += 32;
+ length -= 32;
+ } while (length >= 32);
+
+ a ^= p6 * (rotateRight(c, s1) + d);
+ b ^= p5 * (rotateRight(d, s1) + c);
+ }
+
+ return h32(input, offset, length, a, b);
+ }
+
+ /**
+ * Computes the hash of up to 32 bytes.
+ * Constants in the switch expression are dense; JVM will use them as indices into a table of
+ * instruction pointers (tableswitch instruction), making lookups really fast.
+ */
+ @SuppressWarnings("fallthrough")
+ private static long h32(byte[] input, int offset, int length, long a, long b) {
+ switch (length) {
+ default:
+ b += mux64(fetch64(input, offset), p4);
+ offset += 8;
+ length -= 8;
+ case 24:
+ case 23:
+ case 22:
+ case 21:
+ case 20:
+ case 19:
+ case 18:
+ case 17:
+ a += mux64(fetch64(input, offset), p3);
+ offset += 8;
+ length -= 8;
+ case 16:
+ case 15:
+ case 14:
+ case 13:
+ case 12:
+ case 11:
+ case 10:
+ case 9:
+ b += mux64(fetch64(input, offset), p2);
+ offset += 8;
+ length -= 8;
+ case 8:
+ case 7:
+ case 6:
+ case 5:
+ case 4:
+ case 3:
+ case 2:
+ case 1:
+ a += mux64(tail64(input, offset, length), p1);
+ case 0:
+ // Final weak avalanche
+ return mux64(rotateRight(a + b, s1), p4) + mix64(a ^ b, p0);
+ }
+ }
+
+ /**
+ * XOR the high and low parts of the full 128-bit product.
+ */
+ private static long mux64(long a, long b) {
+ return MUX_64_IMPL.mux64(a, b);
+ }
+
+ /**
+ * XOR-MUL-XOR bit-mixer.
+ */
+ private static long mix64(long a, long b) {
+ a *= b;
+ return a ^ rotateRight(a, s0);
+ }
+
+ /**
+ * Reads "length" bytes starting at "offset" in little-endian order; returned as long.
+ * It is assumed that the length is between 1 and 8 (inclusive); but no defensive checks are made as such.
+ */
+ private static long tail64(byte[] input, int offset, int length) {
+ switch (length) {
+ case 1:
+ return fetch8(input, offset);
+ case 2:
+ return fetch16(input, offset);
+ case 3:
+ return fetch16(input, offset) | (fetch8(input, offset + 2) << 16);
+ case 4:
+ return fetch32(input, offset);
+ case 5:
+ return fetch32(input, offset) | (fetch8(input, offset + 4) << 32);
+ case 6:
+ return fetch32(input, offset) | (fetch16(input, offset + 4) << 32);
+ case 7:
+ // This is equivalent to:
+ // return fetch32(input, offset) | (fetch16(input, offset + 4) << 32) | (fetch8(input, offset + 6) << 48);
+ // But reading two ints overlapping by one byte is faster due to lesser instructions.
+ return fetch32(input, offset) | (fetch32(input, offset + 3) << 24);
+ default:
+ return fetch64(input, offset);
+ }
+ }
+
+ /**
+ * Reads a 64-bit long.
+ */
+ private static long fetch64(byte[] input, int offset) {
+ return (long) LONG_HANDLE.get(input, offset);
+ }
+
+ /**
+ * Reads a 32-bit unsigned integer, returned as long.
+ */
+ private static long fetch32(byte[] input, int offset) {
+ return (int) INT_HANDLE.get(input, offset) & 0xFFFFFFFFL;
+ }
+
+ /**
+ * Reads a 16-bit unsigned short, returned as long.
+ */
+ private static long fetch16(byte[] input, int offset) {
+ return (short) SHORT_HANDLE.get(input, offset) & 0xFFFFL;
+ }
+
+ /**
+ * Reads an 8-bit unsigned byte, returned as long.
+ */
+ private static long fetch8(byte[] input, int offset) {
+ return input[offset] & 0xFFL;
+ }
+
+ /**
+ * The implementation of mux64.
+ */
+ @FunctionalInterface
+ private interface Mux64 {
+ long mux64(long a, long b);
+ }
+
+ /**
+ * Provides the fastest available implementation of mux64 on this platform.
+ *
+ *
+ * Ideally, the following should be returned to match the reference implementation:
+ * {@code Math.unsignedMultiplyHigh(a, b) ^ (a * b)}
+ *
+ *
+ * Since unsignedMultiplyHigh isn't available before JDK 18, and calculating it without intrinsics is quite slow,
+ * the multiplyHigh method is used instead. Slight loss in quality is imperceptible for our use-case: a hash table.
+ * {@code Math.multiplyHigh(a, b) ^ (a * b)}
+ *
+ *
+ * This indirection can be removed once we stop supporting older JDKs.
+ */
+ private static Mux64 fastestMux64Impl() {
+ try {
+ final MethodHandle unsignedMultiplyHigh = MethodHandles.publicLookup()
+ .findStatic(Math.class, "unsignedMultiplyHigh", MethodType.methodType(long.class, long.class, long.class));
+ return (a, b) -> {
+ try {
+ return (long) unsignedMultiplyHigh.invokeExact(a, b) ^ (a * b);
+ } catch (Throwable e) {
+ throw new RuntimeException(e);
+ }
+ };
+ } catch (NoSuchMethodException e) {
+ return (a, b) -> Math.multiplyHigh(a, b) ^ (a * b);
+ } catch (IllegalAccessException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/server/src/main/java/org/opensearch/common/component/package-info.java b/libs/common/src/main/java/org/opensearch/common/hash/package-info.java
similarity index 71%
rename from server/src/main/java/org/opensearch/common/component/package-info.java
rename to libs/common/src/main/java/org/opensearch/common/hash/package-info.java
index 34d034b5a3ffb..bd393b8b921ed 100644
--- a/server/src/main/java/org/opensearch/common/component/package-info.java
+++ b/libs/common/src/main/java/org/opensearch/common/hash/package-info.java
@@ -6,5 +6,7 @@
* compatible open source license.
*/
-/** Base Lifecycle Component package. */
-package org.opensearch.common.component;
+/**
+ * Common hashing utilities.
+ */
+package org.opensearch.common.hash;
diff --git a/server/src/main/java/org/opensearch/common/component/AbstractLifecycleComponent.java b/libs/common/src/main/java/org/opensearch/common/lifecycle/AbstractLifecycleComponent.java
similarity index 98%
rename from server/src/main/java/org/opensearch/common/component/AbstractLifecycleComponent.java
rename to libs/common/src/main/java/org/opensearch/common/lifecycle/AbstractLifecycleComponent.java
index 837f8af44bf13..111556fbe43cf 100644
--- a/server/src/main/java/org/opensearch/common/component/AbstractLifecycleComponent.java
+++ b/libs/common/src/main/java/org/opensearch/common/lifecycle/AbstractLifecycleComponent.java
@@ -30,7 +30,7 @@
* GitHub history for details.
*/
-package org.opensearch.common.component;
+package org.opensearch.common.lifecycle;
import java.io.IOException;
import java.io.UncheckedIOException;
diff --git a/server/src/main/java/org/opensearch/common/component/Lifecycle.java b/libs/common/src/main/java/org/opensearch/common/lifecycle/Lifecycle.java
similarity index 97%
rename from server/src/main/java/org/opensearch/common/component/Lifecycle.java
rename to libs/common/src/main/java/org/opensearch/common/lifecycle/Lifecycle.java
index fb12c1fc9ac4b..c1cf9b2998a13 100644
--- a/server/src/main/java/org/opensearch/common/component/Lifecycle.java
+++ b/libs/common/src/main/java/org/opensearch/common/lifecycle/Lifecycle.java
@@ -30,7 +30,9 @@
* GitHub history for details.
*/
-package org.opensearch.common.component;
+package org.opensearch.common.lifecycle;
+
+import org.opensearch.common.annotation.PublicApi;
/**
* Lifecycle state. Allows the following transitions:
@@ -73,15 +75,17 @@
* }
*
*
- * @opensearch.internal
+ * @opensearch.api
*/
+@PublicApi(since = "1.0.0")
public class Lifecycle {
/**
* State in the lifecycle
*
- * @opensearch.internal
+ * @opensearch.api
*/
+ @PublicApi(since = "1.0.0")
public enum State {
INITIALIZED,
STOPPED,
diff --git a/server/src/main/java/org/opensearch/common/component/LifecycleComponent.java b/libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleComponent.java
similarity index 91%
rename from server/src/main/java/org/opensearch/common/component/LifecycleComponent.java
rename to libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleComponent.java
index 984d55df1bdfa..781c276fefe13 100644
--- a/server/src/main/java/org/opensearch/common/component/LifecycleComponent.java
+++ b/libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleComponent.java
@@ -30,15 +30,17 @@
* GitHub history for details.
*/
-package org.opensearch.common.component;
+package org.opensearch.common.lifecycle;
+import org.opensearch.common.annotation.PublicApi;
import org.opensearch.common.lease.Releasable;
/**
* Base interface for a lifecycle component.
*
- * @opensearch.internal
+ * @opensearch.api
*/
+@PublicApi(since = "1.0.0")
public interface LifecycleComponent extends Releasable {
Lifecycle.State lifecycleState();
diff --git a/server/src/main/java/org/opensearch/common/component/LifecycleListener.java b/libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleListener.java
similarity index 97%
rename from server/src/main/java/org/opensearch/common/component/LifecycleListener.java
rename to libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleListener.java
index 89c344b955bc9..7ac41a5eb0df0 100644
--- a/server/src/main/java/org/opensearch/common/component/LifecycleListener.java
+++ b/libs/common/src/main/java/org/opensearch/common/lifecycle/LifecycleListener.java
@@ -30,7 +30,7 @@
* GitHub history for details.
*/
-package org.opensearch.common.component;
+package org.opensearch.common.lifecycle;
/**
* Base lifecycle listener.
diff --git a/libs/common/src/main/java/org/opensearch/common/lifecycle/package-info.java b/libs/common/src/main/java/org/opensearch/common/lifecycle/package-info.java
new file mode 100644
index 0000000000000..1bedde5585e36
--- /dev/null
+++ b/libs/common/src/main/java/org/opensearch/common/lifecycle/package-info.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Foundation implementation for a object lifecycle.
+ *
+ * See {@link org.opensearch.common.lifecycle.Lifecycle} for example usage
+ *
+ * @opensearch.internal
+ */
+package org.opensearch.common.lifecycle;
diff --git a/server/src/main/java/org/opensearch/common/network/Cidrs.java b/libs/common/src/main/java/org/opensearch/common/network/Cidrs.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/Cidrs.java
rename to libs/common/src/main/java/org/opensearch/common/network/Cidrs.java
diff --git a/server/src/main/java/org/opensearch/common/network/InetAddresses.java b/libs/common/src/main/java/org/opensearch/common/network/InetAddresses.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/InetAddresses.java
rename to libs/common/src/main/java/org/opensearch/common/network/InetAddresses.java
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkAddress.java b/libs/common/src/main/java/org/opensearch/common/network/NetworkAddress.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/NetworkAddress.java
rename to libs/common/src/main/java/org/opensearch/common/network/NetworkAddress.java
diff --git a/libs/common/src/main/java/org/opensearch/common/network/package-info.java b/libs/common/src/main/java/org/opensearch/common/network/package-info.java
new file mode 100644
index 0000000000000..92e4eac5bde42
--- /dev/null
+++ b/libs/common/src/main/java/org/opensearch/common/network/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** common network layer classes used across the code base */
+package org.opensearch.common.network;
diff --git a/server/src/main/java/org/opensearch/common/recycler/AbstractRecycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/AbstractRecycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/AbstractRecycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/AbstractRecycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/AbstractRecyclerC.java b/libs/common/src/main/java/org/opensearch/common/recycler/AbstractRecyclerC.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/AbstractRecyclerC.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/AbstractRecyclerC.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/ConcurrentDequeRecycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/ConcurrentDequeRecycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/ConcurrentDequeRecycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/ConcurrentDequeRecycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/DequeRecycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/DequeRecycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/DequeRecycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/DequeRecycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/FilterRecycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/FilterRecycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/FilterRecycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/FilterRecycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/NoneRecycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/NoneRecycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/NoneRecycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/NoneRecycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/Recycler.java b/libs/common/src/main/java/org/opensearch/common/recycler/Recycler.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/recycler/Recycler.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/Recycler.java
diff --git a/server/src/main/java/org/opensearch/common/recycler/Recyclers.java b/libs/common/src/main/java/org/opensearch/common/recycler/Recyclers.java
similarity index 98%
rename from server/src/main/java/org/opensearch/common/recycler/Recyclers.java
rename to libs/common/src/main/java/org/opensearch/common/recycler/Recyclers.java
index 4cbb80509d6a1..52587144369f1 100644
--- a/server/src/main/java/org/opensearch/common/recycler/Recyclers.java
+++ b/libs/common/src/main/java/org/opensearch/common/recycler/Recyclers.java
@@ -75,6 +75,8 @@ public static A single delimiter can consists of more than one character: It will still
- * be considered as single delimiter string, rather than as bunch of potential
- * delimiter characters - in contrast to A single delimiter can consists of more than one character: It will still
+ * be considered as single delimiter string, rather than as bunch of potential
+ * delimiter characters - in contrast to A single delimiter can consists of more than one character: It will still
@@ -486,33 +526,293 @@ public static SettoString() implementations.
- *
- * @param coll the Collection to display
- * @param delim the delimiter to use (probably a ",")
- * @param prefix the String to start each element with
- * @param suffix the String to end each element with
- * @return the delimited String
- */
- public static String collectionToDelimitedString(Iterable coll, String delim, String prefix, String suffix) {
- StringBuilder sb = new StringBuilder();
- collectionToDelimitedString(coll, delim, prefix, suffix, sb);
- return sb.toString();
- }
-
- public static void collectionToDelimitedString(Iterable coll, String delim, String prefix, String suffix, StringBuilder sb) {
- Iterator it = coll.iterator();
- while (it.hasNext()) {
- sb.append(prefix).append(it.next()).append(suffix);
- if (it.hasNext()) {
- sb.append(delim);
- }
- }
- }
-
- /**
- * Convenience method to return a Collection as a delimited (e.g. CSV)
- * String. E.g. useful for toString() implementations.
- *
- * @param coll the Collection to display
- * @param delim the delimiter to use (probably a ",")
- * @return the delimited String
- */
- public static String collectionToDelimitedString(Iterable coll, String delim) {
- return collectionToDelimitedString(coll, delim, "", "");
- }
-
- /**
- * Convenience method to return a Collection as a CSV String.
- * E.g. useful for toString() implementations.
- *
- * @param coll the Collection to display
- * @return the delimited String
- */
- public static String collectionToCommaDelimitedString(Iterable coll) {
- return collectionToDelimitedString(coll, ",");
- }
+ // no instance:
+ private Strings() {}
- /**
- * Convenience method to return a String array as a delimited (e.g. CSV)
- * String. E.g. useful for toString() implementations.
- *
- * @param arr the array to display
- * @param delim the delimiter to use (probably a ",")
- * @return the delimited String
- */
- public static String arrayToDelimitedString(Object[] arr, String delim) {
- StringBuilder sb = new StringBuilder();
- arrayToDelimitedString(arr, delim, sb);
- return sb.toString();
- }
+ // ---------------------------------------------------------------------
+ // General convenience methods for working with Strings
+ // ---------------------------------------------------------------------
- public static void arrayToDelimitedString(Object[] arr, String delim, StringBuilder sb) {
- if (isEmpty(arr)) {
- return;
- }
- for (int i = 0; i < arr.length; i++) {
- if (i > 0) {
- sb.append(delim);
+ public static void spaceify(int spaces, String from, StringBuilder to) throws Exception {
+ try (BufferedReader reader = new BufferedReader(new StringReader(from))) {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ for (int i = 0; i < spaces; i++) {
+ to.append(' ');
+ }
+ to.append(line).append('\n');
}
- sb.append(arr[i]);
}
}
- /**
- * Convenience method to return a String array as a CSV String.
- * E.g. useful for toString() implementations.
- *
- * @param arr the array to display
- * @return the delimited String
- */
- public static String arrayToCommaDelimitedString(Object[] arr) {
- return arrayToDelimitedString(arr, ",");
- }
-
- /**
- * Determine whether the given array is empty:
- * i.e. null or of zero length.
- *
- * @param array the array to check
- */
- private static boolean isEmpty(Object[] array) {
- return (array == null || array.length == 0);
- }
-
/**
* Check that the given CharSequence is neither null nor of length 0.
* Note: Will return true for a CharSequence that purely consists of whitespace.
@@ -161,6 +87,18 @@ public static boolean hasLength(CharSequence str) {
return (str != null && str.length() > 0);
}
+ /**
+ * Check that the given BytesReference is neither null nor of length 0
+ * Note: Will return true for a BytesReference that purely consists of whitespace.
+ *
+ * @param bytesReference the BytesReference to check (may be null)
+ * @return true if the BytesReference is not null and has length
+ * @see Strings#hasLength(CharSequence)
+ */
+ public static boolean hasLength(final BytesReference bytesReference) {
+ return (bytesReference != null && bytesReference.length() > 0);
+ }
+
/**
* Check that the given String is neither null nor of length 0.
* Note: Will return true for a String that purely consists of whitespace.
@@ -169,7 +107,7 @@ public static boolean hasLength(CharSequence str) {
* @return true if the String is not null and has length
* @see Strings#hasLength(CharSequence)
*/
- public static boolean hasLength(String str) {
+ public static boolean hasLength(final String str) {
return hasLength((CharSequence) str);
}
@@ -186,7 +124,7 @@ public static boolean hasLength(String str) {
* @param str the CharSequence to check (may be null)
* @return true if the CharSequence is either null or has a zero length
*/
- public static boolean isEmpty(CharSequence str) {
+ public static boolean isEmpty(final CharSequence str) {
return hasLength(str) == false;
}
@@ -234,6 +172,42 @@ public static boolean hasText(String str) {
return hasText((CharSequence) str);
}
+ /**
+ * Trim all occurrences of the supplied leading character from the given String.
+ *
+ * @param str the String to check
+ * @param leadingCharacter the leading character to be trimmed
+ * @return the trimmed String
+ */
+ public static String trimLeadingCharacter(String str, char leadingCharacter) {
+ if (hasLength(str) == false) {
+ return str;
+ }
+ StringBuilder sb = new StringBuilder(str);
+ while (sb.length() > 0 && sb.charAt(0) == leadingCharacter) {
+ sb.deleteCharAt(0);
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Test whether the given string matches the given substring
+ * at the given index.
+ *
+ * @param str the original string (or StringBuilder)
+ * @param index the index in the original string to start matching against
+ * @param substring the substring to match at the given index
+ */
+ public static boolean substringMatch(CharSequence str, int index, CharSequence substring) {
+ for (int j = 0; j < substring.length(); j++) {
+ int i = index + j;
+ if (i >= str.length() || str.charAt(i) != substring.charAt(j)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
/**
* Replace all occurrences of a substring within a string with
* another string.
@@ -263,24 +237,6 @@ public static String replace(String inString, String oldPattern, String newPatte
return sb.toString();
}
- /**
- * Trim all occurrences of the supplied leading character from the given String.
- *
- * @param str the String to check
- * @param leadingCharacter the leading character to be trimmed
- * @return the trimmed String
- */
- public static String trimLeadingCharacter(String str, char leadingCharacter) {
- if (hasLength(str) == false) {
- return str;
- }
- StringBuilder sb = new StringBuilder(str);
- while (sb.length() > 0 && sb.charAt(0) == leadingCharacter) {
- sb.deleteCharAt(0);
- }
- return sb.toString();
- }
-
/**
* Delete all occurrences of the given substring.
*
@@ -314,16 +270,65 @@ public static String deleteAny(String inString, String charsToDelete) {
return sb.toString();
}
- public static void spaceify(int spaces, String from, StringBuilder to) throws Exception {
- try (BufferedReader reader = new BufferedReader(new StringReader(from))) {
- String line;
- while ((line = reader.readLine()) != null) {
- for (int i = 0; i < spaces; i++) {
- to.append(' ');
- }
- to.append(line).append('\n');
+ // ---------------------------------------------------------------------
+ // Convenience methods for working with formatted Strings
+ // ---------------------------------------------------------------------
+
+ /**
+ * Quote the given String with single quotes.
+ *
+ * @param str the input String (e.g. "myString")
+ * @return the quoted String (e.g. "'myString'"),
+ * or null if the input was null
+ */
+ public static String quote(String str) {
+ return (str != null ? "'" + str + "'" : null);
+ }
+
+ /**
+ * Capitalize a String, changing the first letter to
+ * upper case as per {@link Character#toUpperCase(char)}.
+ * No other letters are changed.
+ *
+ * @param str the String to capitalize, may be null
+ * @return the capitalized String, null if null
+ */
+ public static String capitalize(String str) {
+ return changeFirstCharacterCase(str, true);
+ }
+
+ private static String changeFirstCharacterCase(String str, boolean capitalize) {
+ if (str == null || str.length() == 0) {
+ return str;
+ }
+ StringBuilder sb = new StringBuilder(str.length());
+ if (capitalize) {
+ sb.append(Character.toUpperCase(str.charAt(0)));
+ } else {
+ sb.append(Character.toLowerCase(str.charAt(0)));
+ }
+ sb.append(str.substring(1));
+ return sb.toString();
+ }
+
+ public static boolean validFileName(String fileName) {
+ for (int i = 0; i < fileName.length(); i++) {
+ char c = fileName.charAt(i);
+ if (INVALID_FILENAME_CHARS.contains(c)) {
+ return false;
}
}
+ return true;
+ }
+
+ public static boolean validFileNameExcludingAstrix(String fileName) {
+ for (int i = 0; i < fileName.length(); i++) {
+ char c = fileName.charAt(i);
+ if (c != '*' && INVALID_FILENAME_CHARS.contains(c)) {
+ return false;
+ }
+ }
+ return true;
}
/**
@@ -341,47 +346,6 @@ public static String[] toStringArray(final CollectiontokenizeToStringArray.
- *
- * @param str the input String
- * @param delimiter the delimiter between elements (this is a single delimiter,
- * rather than a bunch individual delimiter characters)
- * @param charsToDelete a set of characters to delete. Useful for deleting unwanted
- * line breaks: e.g. "\r\n\f" will delete all new lines and line feeds in a String.
- * @return an array of the tokens in the list
- * @see #tokenizeToStringArray
- */
- public static String[] delimitedListToStringArray(String str, String delimiter, String charsToDelete) {
- if (str == null) {
- return Strings.EMPTY_ARRAY;
- }
- if (delimiter == null) {
- return new String[] { str };
- }
- Listnull if the delimiter wasn't found in the given input String
+ */
+ public static String[] split(String toSplit, String delimiter) {
+ if (hasLength(toSplit) == false || hasLength(delimiter) == false) {
+ return null;
+ }
+ int offset = toSplit.indexOf(delimiter);
+ if (offset < 0) {
+ return null;
+ }
+ String beforeDelimiter = toSplit.substring(0, offset);
+ String afterDelimiter = toSplit.substring(offset + delimiter.length());
+ return new String[] { beforeDelimiter, afterDelimiter };
+ }
+
/**
* Tokenize the given String into a String array via a StringTokenizer.
* Trims tokens and omits empty tokens.
@@ -446,6 +445,47 @@ private static tokenizeToStringArray.
+ *
+ * @param str the input String
+ * @param delimiter the delimiter between elements (this is a single delimiter,
+ * rather than a bunch individual delimiter characters)
+ * @param charsToDelete a set of characters to delete. Useful for deleting unwanted
+ * line breaks: e.g. "\r\n\f" will delete all new lines and line feeds in a String.
+ * @return an array of the tokens in the list
+ * @see #tokenizeToStringArray
+ */
+ public static String[] delimitedListToStringArray(String str, String delimiter, String charsToDelete) {
+ if (str == null) {
+ return Strings.EMPTY_ARRAY;
+ }
+ if (delimiter == null) {
+ return new String[] { str };
+ }
+ ListtoString() implementations.
+ *
+ * @param coll the Collection to display
+ * @param delim the delimiter to use (probably a ",")
+ * @param prefix the String to start each element with
+ * @param suffix the String to end each element with
+ * @return the delimited String
+ */
+ public static String collectionToDelimitedString(Iterable coll, String delim, String prefix, String suffix) {
+ StringBuilder sb = new StringBuilder();
+ collectionToDelimitedString(coll, delim, prefix, suffix, sb);
+ return sb.toString();
+ }
+
+ public static void collectionToDelimitedString(Iterable coll, String delim, String prefix, String suffix, StringBuilder sb) {
+ Iterator it = coll.iterator();
+ while (it.hasNext()) {
+ sb.append(prefix).append(it.next()).append(suffix);
+ if (it.hasNext()) {
+ sb.append(delim);
+ }
+ }
}
/**
- * Capitalize a String, changing the first letter to
- * upper case as per {@link Character#toUpperCase(char)}.
- * No other letters are changed.
+ * Convenience method to return a Collection as a delimited (e.g. CSV)
+ * String. E.g. useful for toString() implementations.
*
- * @param str the String to capitalize, may be null
- * @return the capitalized String, null if null
+ * @param coll the Collection to display
+ * @param delim the delimiter to use (probably a ",")
+ * @return the delimited String
*/
- public static String capitalize(String str) {
- return changeFirstCharacterCase(str, true);
+ public static String collectionToDelimitedString(Iterable coll, String delim) {
+ return collectionToDelimitedString(coll, delim, "", "");
}
- private static String changeFirstCharacterCase(String str, boolean capitalize) {
- if (str == null || str.length() == 0) {
- return str;
+ /**
+ * Convenience method to return a Collection as a CSV String.
+ * E.g. useful for toString() implementations.
+ *
+ * @param coll the Collection to display
+ * @return the delimited String
+ */
+ public static String collectionToCommaDelimitedString(Iterable coll) {
+ return collectionToDelimitedString(coll, ",");
+ }
+
+ /**
+ * Convenience method to return a String array as a delimited (e.g. CSV)
+ * String. E.g. useful for toString() implementations.
+ *
+ * @param arr the array to display
+ * @param delim the delimiter to use (probably a ",")
+ * @return the delimited String
+ */
+ public static String arrayToDelimitedString(Object[] arr, String delim) {
+ StringBuilder sb = new StringBuilder();
+ arrayToDelimitedString(arr, delim, sb);
+ return sb.toString();
+ }
+
+ public static void arrayToDelimitedString(Object[] arr, String delim, StringBuilder sb) {
+ if (isEmpty(arr)) {
+ return;
}
- StringBuilder sb = new StringBuilder(str.length());
- if (capitalize) {
- sb.append(Character.toUpperCase(str.charAt(0)));
+ for (int i = 0; i < arr.length; i++) {
+ if (i > 0) {
+ sb.append(delim);
+ }
+ sb.append(arr[i]);
+ }
+ }
+
+ /**
+ * Convenience method to return a String array as a CSV String.
+ * E.g. useful for toString() implementations.
+ *
+ * @param arr the array to display
+ * @return the delimited String
+ */
+ public static String arrayToCommaDelimitedString(Object[] arr) {
+ return arrayToDelimitedString(arr, ",");
+ }
+
+ /**
+ * Format the double value with a single decimal points, trimming trailing '.0'.
+ */
+ public static String format1Decimals(double value, String suffix) {
+ String p = String.valueOf(value);
+ int ix = p.indexOf('.') + 1;
+ int ex = p.indexOf('E');
+ char fraction = p.charAt(ix);
+ if (fraction == '0') {
+ if (ex != -1) {
+ return p.substring(0, ix - 1) + p.substring(ex) + suffix;
+ } else {
+ return p.substring(0, ix - 1) + suffix;
+ }
} else {
- sb.append(Character.toLowerCase(str.charAt(0)));
+ if (ex != -1) {
+ return p.substring(0, ix) + fraction + p.substring(ex) + suffix;
+ } else {
+ return p.substring(0, ix) + fraction + suffix;
+ }
}
- sb.append(str.substring(1));
- return sb.toString();
+ }
+
+ /**
+ * Determine whether the given array is empty:
+ * i.e. null or of zero length.
+ *
+ * @param array the array to check
+ */
+ private static boolean isEmpty(final Object[] array) {
+ return (array == null || array.length == 0);
+ }
+
+ public static byte[] toUTF8Bytes(CharSequence charSequence) {
+ return toUTF8Bytes(charSequence, new BytesRefBuilder());
+ }
+
+ public static byte[] toUTF8Bytes(CharSequence charSequence, BytesRefBuilder spare) {
+ spare.copyChars(charSequence);
+ return Arrays.copyOf(spare.bytes(), spare.length());
+ }
+
+ /**
+ * Return substring(beginIndex, endIndex) that is impervious to string length.
+ */
+ public static String substring(String s, int beginIndex, int endIndex) {
+ if (s == null) {
+ return s;
+ }
+
+ int realEndIndex = s.length() > 0 ? s.length() - 1 : 0;
+
+ if (endIndex > realEndIndex) {
+ return s.substring(beginIndex);
+ } else {
+ return s.substring(beginIndex, endIndex);
+ }
+ }
+
+ /**
+ * If an array only consists of zero or one element, which is "*" or "_all" return an empty array
+ * which is usually used as everything
+ */
+ public static boolean isAllOrWildcard(String[] data) {
+ return CollectionUtils.isEmpty(data) || data.length == 1 && isAllOrWildcard(data[0]);
+ }
+
+ /**
+ * Returns `true` if the string is `_all` or `*`.
+ */
+ public static boolean isAllOrWildcard(String data) {
+ return "_all".equals(data) || "*".equals(data);
+ }
+
+ /**
+ * Return a {@link String} that is the json representation of the provided {@link ToXContent}.
+ * Wraps the output into an anonymous object if needed. The content is not pretty-printed
+ * nor human readable.
+ */
+ public static String toString(MediaType mediaType, ToXContent toXContent) {
+ return toString(mediaType, toXContent, false, false);
+ }
+
+ /**
+ * Return a {@link String} that is the json representation of the provided {@link ToXContent}.
+ * Wraps the output into an anonymous object if needed.
+ * Allows to configure the params.
+ * The content is not pretty-printed nor human readable.
+ */
+ public static String toString(MediaType mediaType, ToXContent toXContent, ToXContent.Params params) {
+ return toString(mediaType, toXContent, params, false, false);
+ }
+
+ /**
+ * Return a {@link String} that is the json representation of the provided {@link ToXContent}.
+ * Wraps the output into an anonymous object if needed. Allows to control whether the outputted
+ * json needs to be pretty printed and human readable.
+ *
+ */
+ public static String toString(MediaType mediaType, ToXContent toXContent, boolean pretty, boolean human) {
+ return toString(mediaType, toXContent, ToXContent.EMPTY_PARAMS, pretty, human);
+ }
+
+ /**
+ * Return a {@link String} that is the json representation of the provided {@link ToXContent}.
+ * Wraps the output into an anonymous object if needed.
+ * Allows to configure the params.
+ * Allows to control whether the outputted json needs to be pretty printed and human readable.
+ */
+ private static String toString(MediaType mediaType, ToXContent toXContent, ToXContent.Params params, boolean pretty, boolean human) {
+ try {
+ XContentBuilder builder = createBuilder(mediaType, pretty, human);
+ if (toXContent.isFragment()) {
+ builder.startObject();
+ }
+ toXContent.toXContent(builder, params);
+ if (toXContent.isFragment()) {
+ builder.endObject();
+ }
+ return builder.toString();
+ } catch (IOException e) {
+ try {
+ XContentBuilder builder = createBuilder(mediaType, pretty, human);
+ builder.startObject();
+ builder.field("error", "error building toString out of XContent: " + e.getMessage());
+ builder.field("stack_trace", ExceptionsHelper.stackTrace(e));
+ builder.endObject();
+ return builder.toString();
+ } catch (IOException e2) {
+ throw new OpenSearchException("cannot generate error message for deserialization", e);
+ }
+ }
+ }
+
+ private static XContentBuilder createBuilder(MediaType mediaType, boolean pretty, boolean human) throws IOException {
+ XContentBuilder builder = XContentBuilder.builder(mediaType.xContent());
+ if (pretty) {
+ builder.prettyPrint();
+ }
+ if (human) {
+ builder.humanReadable(true);
+ }
+ return builder;
+ }
+
+ /**
+ * Truncates string to a length less than length. Backtracks to throw out
+ * high surrogates.
+ */
+ public static String cleanTruncate(String s, int length) {
+ if (s == null) {
+ return s;
+ }
+ /*
+ * Its pretty silly for you to truncate to 0 length but just in case
+ * someone does this shouldn't break.
+ */
+ if (length == 0) {
+ return "";
+ }
+ if (length >= s.length()) {
+ return s;
+ }
+ if (Character.isHighSurrogate(s.charAt(length - 1))) {
+ length--;
+ }
+ return s.substring(0, length);
+ }
+
+ public static boolean isNullOrEmpty(@Nullable String s) {
+ return s == null || s.isEmpty();
+ }
+
+ public static String padStart(String s, int minimumLength, char c) {
+ if (s == null) {
+ throw new NullPointerException("s");
+ }
+ if (s.length() >= minimumLength) {
+ return s;
+ } else {
+ StringBuilder sb = new StringBuilder(minimumLength);
+ for (int i = s.length(); i < minimumLength; i++) {
+ sb.append(c);
+ }
+
+ sb.append(s);
+ return sb.toString();
+ }
+ }
+
+ public static String toLowercaseAscii(String in) {
+ StringBuilder out = new StringBuilder();
+ Iterator