Use new BaseText and BaseBytesReference types

libs/core/src/main/java/org/elasticsearch/core/BaseText.java

@@ -21,11 +21,17 @@
 public class BaseText {
     protected BaseBytesReference bytes;
     private String text;
+    private int length = -1;
 
     public BaseText(BaseBytesReference bytes) {
         this.bytes = bytes;
     }
 
+    public BaseText(BaseBytesReference bytes, int length) {
+        this.bytes = bytes;
+        this.length = length;
+    }
+
     public BaseText(String text) {
         this.text = text;
     }
@@ -69,4 +75,10 @@ public String toString() {
         return string();
     }
 
+    public int length() {
+        if (length < 0) {
+            length = string().length();
+        }
+        return length;
+    }
 }

libs/core/src/main/java/org/elasticsearch/core/bytes/BaseBytesArray.java

@@ -14,6 +14,9 @@ public class BaseBytesArray implements BaseBytesReference {
     private final int offset;
     private final int length;
 
+    int hash = 0;
+    boolean hashIsZero = false;
+
     public BaseBytesArray(byte[] bytes) {
         this(bytes, 0, bytes.length);
     }
@@ -48,4 +51,36 @@ public byte[] array() {
     public int arrayOffset() {
         return offset;
     }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (other instanceof final BaseBytesReference otherRef) {
+            if (length != otherRef.length()) {
+                return false;
+            }
+            for (int i = 0; i < length; i++) {
+                if (get(i) != otherRef.get(i)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        if (hash == 0 && hashIsZero == false) {
+            hash = 1;
+            for (int i = offset; i < length; i++) {
+                hash = 31 * hash + bytes[i];
+            }
+            if (hash == 0) {
+                hashIsZero = true;
+            }
+        }
+        return hash;
+    }
 }

libs/x-content/impl/src/main/java/org/elasticsearch/xcontent/provider/json/ESUTF8StreamJsonParser.java

@@ -16,7 +16,8 @@
 import com.fasterxml.jackson.core.json.UTF8StreamJsonParser;
 import com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer;
 
-import org.elasticsearch.xcontent.XContentString;
+import org.elasticsearch.core.BaseText;
+import org.elasticsearch.core.bytes.BaseBytesArray;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -44,20 +45,20 @@ public ESUTF8StreamJsonParser(
      * This is only a best-effort attempt; if there is some reason the bytes cannot be retrieved, this method will return null.
      * Currently, this is only implemented for ascii-only strings that do not contain escaped characters.
      */
-    public XContentString getValueAsByteRef() throws IOException {
+    public BaseText getValueAsText() throws IOException {
         if (_currToken == JsonToken.VALUE_STRING && _tokenIncomplete) {
             if (stringEnd > 0) {
                 final int len = stringEnd - 1 - _inputPtr;
                 // For now, we can use `len` for `charCount` because we only support ascii-encoded unescaped strings,
                 // which means each character uses exactly 1 byte.
-                return new XContentString(new XContentString.ByteRef(_inputBuffer, _inputPtr, len), len);
+                return new BaseText(new BaseBytesArray(_inputBuffer, _inputPtr, len), len);
             }
-            return _finishAndReturnByteRef();
+            return _finishAndReturnText();
         }
         return null;
     }
 
-    protected XContentString _finishAndReturnByteRef() throws IOException {
+    protected BaseText _finishAndReturnText() throws IOException {
         int ptr = _inputPtr;
         if (ptr >= _inputEnd) {
             _loadMoreGuaranteed();
@@ -76,7 +77,7 @@ protected XContentString _finishAndReturnByteRef() throws IOException {
                     final int len = ptr - startPtr;
                     // For now, we can use `len` for `charCount` because we only support ascii-encoded unescaped strings,
                     // which means each character uses exactly 1 byte.
-                    return new XContentString(new XContentString.ByteRef(inputBuffer, startPtr, len), len);
+                    return new BaseText(new BaseBytesArray(inputBuffer, startPtr, len), len);
                 }
                 return null;
             }

libs/x-content/impl/src/main/java/org/elasticsearch/xcontent/provider/json/JsonXContentParser.java

@@ -17,12 +17,12 @@
 import com.fasterxml.jackson.core.exc.InputCoercionException;
 import com.fasterxml.jackson.core.io.JsonEOFException;
 
+import org.elasticsearch.core.BaseText;
 import org.elasticsearch.core.IOUtils;
 import org.elasticsearch.xcontent.XContentEOFException;
 import org.elasticsearch.xcontent.XContentLocation;
 import org.elasticsearch.xcontent.XContentParseException;
 import org.elasticsearch.xcontent.XContentParserConfiguration;
-import org.elasticsearch.xcontent.XContentString;
 import org.elasticsearch.xcontent.XContentType;
 import org.elasticsearch.xcontent.provider.XContentParserConfigurationImpl;
 import org.elasticsearch.xcontent.support.AbstractXContentParser;
@@ -117,17 +117,17 @@ public String text() throws IOException {
     }
 
     @Override
-    public XContentString xContentText() throws IOException {
+    public BaseText xContentText() throws IOException {
         if (currentToken().isValue() == false) {
             throwOnNoText();
         }
         if (parser instanceof ESUTF8StreamJsonParser esParser) {
-            var bytesRef = esParser.getValueAsByteRef();
-            if (bytesRef != null) {
-                return bytesRef;
+            var text = esParser.getValueAsText();
+            if (text != null) {
+                return text;
             }
         }
-        return new XContentString(text());
+        return new BaseText(text());
     }
 
     private void throwOnNoText() {

libs/x-content/impl/src/test/java/org/elasticsearch/xcontent/provider/json/ESUTF8StreamJsonParserTests.java

@@ -15,15 +15,15 @@
 
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.core.CheckedConsumer;
+import org.elasticsearch.core.bytes.BaseBytesArray;
+import org.elasticsearch.core.bytes.BaseBytesReference;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.xcontent.XContentBuilder;
-import org.elasticsearch.xcontent.XContentString;
 import org.elasticsearch.xcontent.json.JsonXContent;
 import org.hamcrest.Matchers;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 
 public class ESUTF8StreamJsonParserTests extends ESTestCase {
 
@@ -36,9 +36,8 @@ private void testParseJson(String input, CheckedConsumer<ESUTF8StreamJsonParser,
         test.accept((ESUTF8StreamJsonParser) parser);
     }
 
-    private void assertTextRef(XContentString.ByteRef textRef, String expectedValue) {
-        var data = Arrays.copyOfRange(textRef.bytes(), textRef.offset(), textRef.offset() + textRef.length());
-        assertThat(data, Matchers.equalTo(StandardCharsets.UTF_8.encode(expectedValue).array()));
+    private void assertTextBytes(BaseBytesReference textRef, String expectedValue) {
+        assertThat(textRef, Matchers.equalTo(new BaseBytesArray(expectedValue.getBytes(StandardCharsets.UTF_8))));
     }
 
     public void testGetValueAsByteRef() throws IOException {
@@ -47,14 +46,14 @@ public void testGetValueAsByteRef() throws IOException {
             assertThat(parser.nextFieldName(), Matchers.equalTo("foo"));
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
 
-            XContentString.ByteRef textRef = parser.getValueAsByteRef().getBytes();
+            var textRef = parser.getValueAsText().bytes();
             assertThat(textRef, Matchers.notNullValue());
-            assertThat(textRef.offset(), Matchers.equalTo(9));
+            assertThat(textRef.arrayOffset(), Matchers.equalTo(9));
             assertThat(textRef.length(), Matchers.equalTo(3));
-            assertTextRef(textRef, "bar");
+            assertTextBytes(textRef, "bar");
 
             assertThat(parser.getValueAsString(), Matchers.equalTo("bar"));
-            assertThat(parser.getValueAsByteRef(), Matchers.nullValue());
+            assertThat(parser.getValueAsText(), Matchers.nullValue());
 
             assertThat(parser.nextToken(), Matchers.equalTo(JsonToken.END_OBJECT));
         });
@@ -64,7 +63,7 @@ public void testGetValueAsByteRef() throws IOException {
             assertThat(parser.nextFieldName(), Matchers.equalTo("foo"));
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
 
-            assertThat(parser.getValueAsByteRef(), Matchers.nullValue());
+            assertThat(parser.getValueAsText(), Matchers.nullValue());
             assertThat(parser.getValueAsString(), Matchers.equalTo("bar\"baz\""));
         });
 
@@ -73,7 +72,7 @@ public void testGetValueAsByteRef() throws IOException {
             assertThat(parser.nextFieldName(), Matchers.equalTo("foo"));
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
 
-            assertThat(parser.getValueAsByteRef(), Matchers.nullValue());
+            assertThat(parser.getValueAsText(), Matchers.nullValue());
             assertThat(parser.getValueAsString(), Matchers.equalTo("bår"));
         });
 
@@ -84,29 +83,29 @@ public void testGetValueAsByteRef() throws IOException {
 
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
             {
-                XContentString.ByteRef textRef = parser.getValueAsByteRef().getBytes();
+                var textRef = parser.getValueAsText().bytes();
                 assertThat(textRef, Matchers.notNullValue());
-                assertThat(textRef.offset(), Matchers.equalTo(10));
+                assertThat(textRef.arrayOffset(), Matchers.equalTo(10));
                 assertThat(textRef.length(), Matchers.equalTo(5));
-                assertTextRef(textRef, "lorem");
+                assertTextBytes(textRef, "lorem");
             }
 
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
             {
-                XContentString.ByteRef textRef = parser.getValueAsByteRef().getBytes();
+                var textRef = parser.getValueAsText().bytes();
                 assertThat(textRef, Matchers.notNullValue());
-                assertThat(textRef.offset(), Matchers.equalTo(19));
+                assertThat(textRef.arrayOffset(), Matchers.equalTo(19));
                 assertThat(textRef.length(), Matchers.equalTo(5));
-                assertTextRef(textRef, "ipsum");
+                assertTextBytes(textRef, "ipsum");
             }
 
             assertThat(parser.nextValue(), Matchers.equalTo(JsonToken.VALUE_STRING));
             {
-                XContentString.ByteRef textRef = parser.getValueAsByteRef().getBytes();
+                var textRef = parser.getValueAsText().bytes();
                 assertThat(textRef, Matchers.notNullValue());
-                assertThat(textRef.offset(), Matchers.equalTo(28));
+                assertThat(textRef.arrayOffset(), Matchers.equalTo(28));
                 assertThat(textRef.length(), Matchers.equalTo(5));
-                assertTextRef(textRef, "dolor");
+                assertTextBytes(textRef, "dolor");
             }
 
             assertThat(parser.nextToken(), Matchers.equalTo(JsonToken.END_ARRAY));
@@ -151,9 +150,9 @@ public void testGetValueRandomized() throws IOException {
 
                 String currVal = values[i];
                 if (validForTextRef(currVal)) {
-                    assertTextRef(parser.getValueAsByteRef().getBytes(), currVal);
+                    assertTextBytes(parser.getValueAsText().bytes(), currVal);
                 } else {
-                    assertThat(parser.getValueAsByteRef(), Matchers.nullValue());
+                    assertThat(parser.getValueAsText(), Matchers.nullValue());
                     assertThat(parser.getValueAsString(), Matchers.equalTo(currVal));
                 }
             }

libs/x-content/src/main/java/org/elasticsearch/xcontent/FilterXContentParser.java

@@ -9,6 +9,7 @@
 
 package org.elasticsearch.xcontent;
 
+import org.elasticsearch.core.BaseText;
 import org.elasticsearch.core.CheckedFunction;
 import org.elasticsearch.core.RestApiVersion;
 
@@ -100,11 +101,11 @@ public String textOrNull() throws IOException {
         return delegate().textOrNull();
     }
 
-    public XContentString xContentText() throws IOException {
+    public BaseText xContentText() throws IOException {
         return delegate().xContentText();
     }
 
-    public XContentString xContentTextOrNull() throws IOException {
+    public BaseText xContentTextOrNull() throws IOException {
         return delegate().xContentTextOrNull();
     }
 

libs/x-content/src/main/java/org/elasticsearch/xcontent/XContentParser.java

@@ -9,6 +9,7 @@
 
 package org.elasticsearch.xcontent;
 
+import org.elasticsearch.core.BaseText;
 import org.elasticsearch.core.CheckedFunction;
 import org.elasticsearch.core.Nullable;
 import org.elasticsearch.core.RestApiVersion;
@@ -109,9 +110,9 @@ <T> Map<String, T> map(Supplier<Map<String, T>> mapFactory, CheckedFunction<XCon
 
     String textOrNull() throws IOException;
 
-    XContentString xContentText() throws IOException;
+    BaseText xContentText() throws IOException;
 
-    XContentString xContentTextOrNull() throws IOException;
+    BaseText xContentTextOrNull() throws IOException;
 
     CharBuffer charBufferOrNull() throws IOException;