Added "cjk" analyzer.

CHANGELOG.md

@@ -5,6 +5,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ### Added
 - Document HTTP/2 support ([#330](https://github.com/opensearch-project/opensearch-java/pull/330))
+- Added support for "cjk" analyzer ([#604](https://github.com/opensearch-project/opensearch-java/pull/604))
 
 ### Dependencies
 - Bumps `org.ajoberstar.grgit:grgit-gradle` from 5.0.0 to 5.2.0

java-client/src/main/java/org/opensearch/client/opensearch/_types/analysis/Analyzer.java

@@ -90,7 +90,9 @@ public enum Kind implements JsonEnum {
 
 		Whitespace("whitespace"),
 
-        Smartcn("smartcn"),
+		Smartcn("smartcn"),
+
+		Cjk("cjk"),
 
 		;
 
@@ -393,6 +395,24 @@ public SmartcnAnalyzer smartcn() {
     }
 
 
+    /**
+     * Is this variant instance of kind {@code cjk}?
+     */
+    public boolean isCjk() {
+        return _kind == Kind.Cjk;
+    }
+
+    /**
+     * Get the {@code cjk} variant value.
+     *
+     * @throws IllegalStateException
+     *             if the current variant is not of the {@code cjk} kind.
+     */
+    public CjkAnalyzer cjk() {
+        return TaggedUnionUtils.get(this, Kind.Cjk);
+    }
+
+
     @Override
 	public void serialize(JsonGenerator generator, JsonpMapper mapper) {
 
@@ -560,6 +580,17 @@ public ObjectBuilder<Analyzer> smartcn() {
             return this.smartcn(new SmartcnAnalyzer.Builder().build());
 		}
 
+		public ObjectBuilder<Analyzer> cjk(CjkAnalyzer v) {
+			this._kind = Kind.Cjk;
+			this._value = v;
+			return this;
+		}
+
+		public ObjectBuilder<Analyzer> cjk(
+				Function<CjkAnalyzer.Builder, ObjectBuilder<CjkAnalyzer>> fn) {
+			return this.cjk(fn.apply(new CjkAnalyzer.Builder()).build());
+		}
+
 		public Analyzer build() {
 			_checkSingleUse();
 			return new Analyzer(this);
@@ -584,6 +615,7 @@ protected static void setupAnalyzerDeserializer(ObjectDeserializer<Builder> op)
 		op.add(Builder::stop, StopAnalyzer._DESERIALIZER, "stop");
 		op.add(Builder::whitespace, WhitespaceAnalyzer._DESERIALIZER, "whitespace");
 		op.add(Builder::smartcn, SmartcnAnalyzer._DESERIALIZER, Kind.Smartcn.jsonValue());
+		op.add(Builder::cjk, CjkAnalyzer._DESERIALIZER, Kind.Cjk.jsonValue());
 
 		op.setTypeProperty("type", null);
 

java-client/src/main/java/org/opensearch/client/opensearch/_types/analysis/CjkAnalyzer.java

@@ -0,0 +1,182 @@
+/*
+ * 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.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.client.opensearch._types.analysis;
+
+import java.util.List;
+import java.util.function.Function;
+
+import javax.annotation.Nullable;
+
+import org.opensearch.client.json.JsonpDeserializable;
+import org.opensearch.client.json.JsonpDeserializer;
+import org.opensearch.client.json.JsonpMapper;
+import org.opensearch.client.json.JsonpSerializable;
+import org.opensearch.client.json.ObjectBuilderDeserializer;
+import org.opensearch.client.json.ObjectDeserializer;
+import org.opensearch.client.util.ApiTypeHelper;
+import org.opensearch.client.util.ObjectBuilder;
+import org.opensearch.client.util.ObjectBuilderBase;
+
+import jakarta.json.stream.JsonGenerator;
+
+// typedef: _types.analysis.LanguageAnalyzer
+
+@JsonpDeserializable
+public class CjkAnalyzer implements AnalyzerVariant, JsonpSerializable {
+	@Nullable
+	private final List<String> stopwords;
+
+	@Nullable
+	private final String stopwordsPath;
+
+	// ---------------------------------------------------------------------------------------------
+
+	private CjkAnalyzer(Builder builder) {
+
+		this.stopwords = ApiTypeHelper.unmodifiable(builder.stopwords);
+		this.stopwordsPath = builder.stopwordsPath;
+
+	}
+
+	public static CjkAnalyzer of(Function<Builder, ObjectBuilder<CjkAnalyzer>> fn) {
+		return fn.apply(new Builder()).build();
+	}
+
+	/**
+	 * Analyzer variant kind.
+	 */
+	@Override
+	public Analyzer.Kind _analyzerKind() {
+		return Analyzer.Kind.Cjk;
+	}
+
+	/**
+	 * API name: {@code stopwords}
+	 */
+	public final List<String> stopwords() {
+		return this.stopwords;
+	}
+
+	/**
+	 * API name: {@code stopwords_path}
+	 */
+	@Nullable
+	public final String stopwordsPath() {
+		return this.stopwordsPath;
+	}
+
+	/**
+	 * Serialize this object to JSON.
+	 */
+	public void serialize(JsonGenerator generator, JsonpMapper mapper) {
+		generator.writeStartObject();
+		serializeInternal(generator, mapper);
+		generator.writeEnd();
+	}
+
+	protected void serializeInternal(JsonGenerator generator, JsonpMapper mapper) {
+
+		generator.write("type", Analyzer.Kind.Cjk.jsonValue());
+
+
+		if (ApiTypeHelper.isDefined(this.stopwords)) {
+			generator.writeKey("stopwords");
+			generator.writeStartArray();
+			for (String item0 : this.stopwords) {
+				generator.write(item0);
+
+			}
+			generator.writeEnd();
+
+		}
+		if (this.stopwordsPath != null) {
+			generator.writeKey("stopwords_path");
+			generator.write(this.stopwordsPath);
+
+		}
+
+	}
+
+	// ---------------------------------------------------------------------------------------------
+
+	/**
+	 * Builder for {@link CjkAnalyzer}.
+	 */
+
+	public static class Builder extends ObjectBuilderBase implements ObjectBuilder<CjkAnalyzer> {
+		@Nullable
+		private List<String> stopwords;
+
+		@Nullable
+		private String stopwordsPath;
+
+		/**
+		 * API name: {@code stopwords}
+		 * <p>
+		 * Adds all elements of <code>list</code> to <code>stopwords</code>.
+		 */
+		public final Builder stopwords(List<String> list) {
+			this.stopwords = _listAddAll(this.stopwords, list);
+			return this;
+		}
+
+		/**
+		 * API name: {@code stopwords}
+		 * <p>
+		 * Adds one or more values to <code>stopwords</code>.
+		 */
+		public final Builder stopwords(String value, String... values) {
+			this.stopwords = _listAdd(this.stopwords, value, values);
+			return this;
+		}
+
+		/**
+		 * API name: {@code stopwords_path}
+		 */
+		public final Builder stopwordsPath(@Nullable String value) {
+			this.stopwordsPath = value;
+			return this;
+		}
+
+		/**
+		 * Builds a {@link CjkAnalyzer}.
+		 *
+		 * @throws NullPointerException
+		 *             if some required fields are null.
+		 */
+		public CjkAnalyzer build() {
+			_checkSingleUse();
+
+			return new CjkAnalyzer(this);
+		}
+	}
+
+	// ---------------------------------------------------------------------------------------------
+
+	/**
+	 * Json deserializer for {@link CjkAnalyzer}
+	 */
+	public static final JsonpDeserializer<CjkAnalyzer> _DESERIALIZER = ObjectBuilderDeserializer.lazy(Builder::new,
+			CjkAnalyzer::setupLanguageAnalyzerDeserializer);
+
+	protected static void setupLanguageAnalyzerDeserializer(ObjectDeserializer<CjkAnalyzer.Builder> op) {
+
+		op.add(Builder::stopwords, JsonpDeserializer.arrayDeserializer(JsonpDeserializer.stringDeserializer()),
+				"stopwords");
+		op.add(Builder::stopwordsPath, JsonpDeserializer.stringDeserializer(), "stopwords_path");
+
+		op.ignore("type");
+	}
+
+}

java-client/src/test/java/org/opensearch/client/opensearch/experiments/ParsingTests.java

@@ -32,6 +32,8 @@
 
 package org.opensearch.client.opensearch.experiments;
 
+import java.util.List;
+
 import org.junit.Test;
 import org.opensearch.client.opensearch._types.Time;
 import org.opensearch.client.opensearch._types.analysis.Analyzer;
@@ -152,4 +154,23 @@ public void testSmartcn_StopFilter() {
 
         TokenFilterDefinition analyzer2 = fromJson(str, TokenFilterDefinition._DESERIALIZER);
     }
+    @Test
+    public void testCjk_Analyzer() {
+        final Analyzer analyzer = new Analyzer.Builder()
+            .cjk(b -> b
+                .stopwords(List.of("a", "b", "c"))
+                .stopwordsPath("path")
+            )
+            .build();
+
+        assertTrue(analyzer.isCjk());
+
+        String str = toJson(analyzer);
+        assertEquals("{\"type\":\"cjk\",\"stopwords\":[\"a\",\"b\",\"c\"],\"stopwords_path\":\"path\"}", str);
+
+        Analyzer analyzer2 = fromJson(str, Analyzer._DESERIALIZER);
+        assertTrue(analyzer2.isCjk());
+        assertEquals(analyzer.cjk().stopwords(), analyzer2.cjk().stopwords());
+        assertEquals(analyzer.cjk().stopwordsPath(), analyzer2.cjk().stopwordsPath());
+    }
 }