// execution mode.
class AbstractTensorHandle : public core::RefCounted {
 protected:
  enum AbstractTensorHandleKind { kGraph, kMlir, kEager, kTfrt, kCustomDevice };
  explicit AbstractTensorHandle(AbstractTensorHandleKind kind) : kind_(kind) {}
  ~AbstractTensorHandle() override {}

 public:
  // Returns tensor dtype.
  virtual tensorflow::DataType DataType() const = 0;

  // Returns the status of the tensor handle. If it is a tfrt::TensorHandle,

        }

        return merged.toArray(new String[merged.size()]);
    }

    /**
     * Merges two Kind arrays, maintaining uniqueness.
     */
    private static SuggestItem.Kind[] mergeKinds(final SuggestItem.Kind[] kinds1, final SuggestItem.Kind[] kinds2) {
        final Set<SuggestItem.Kind> merged = new LinkedHashSet<>();

        if (kinds1 != null) {
            Collections.addAll(merged, kinds1);
        }

        boolQueryBuilder.must(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.DOCUMENT.toString()));
        boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.QUERY.toString()));
        boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString()));

        source.put(FieldNames.TAGS, Arrays.asList("tag1"));
        source.put(FieldNames.ROLES, Arrays.asList("role1"));
        source.put(FieldNames.LANGUAGES, Arrays.asList("en"));
        source.put(FieldNames.KINDS, Arrays.asList("document"));
        source.put(FieldNames.TIMESTAMP, System.currentTimeMillis());

        SuggestItem item = SuggestItemSerializer.fromSource(source);

        assertNotNull(item);

        SuggestItem.Kind[] result = SuggestItem.concatKinds(new SuggestItem.Kind[0], new SuggestItem.Kind[0]);

        assertEquals(0, result.length);
    }

    @Test
    public void test_concatKinds_firstEmpty() {
        SuggestItem.Kind[] kinds2 = { SuggestItem.Kind.QUERY };

        SuggestItem.Kind[] result = SuggestItem.concatKinds(new SuggestItem.Kind[0], kinds2);

    kGraph,
    kMlir,
    kEager,
    kTfrt,
    kTape,
    kOpHandler
  };
  explicit AbstractOperation(AbstractOperationKind kind) : kind_(kind) {}
  virtual ~AbstractOperation() {}

 public:
  AbstractOperationKind getKind() const { return kind_; }

  // Release any underlying resources, including the interface object.
  //
  // WARNING: The destructor of this class is marked as protected to disallow

    /** The document frequency field. */
    public static final String DOC_FREQ = "docFreq";
    /** The user boost field. */
    public static final String USER_BOOST = "userBoost";
    /** The kinds field. */
    public static final String KINDS = "kinds";
    /** The timestamp field. */
    public static final String TIMESTAMP = "@timestamp";
    /** The tags field. */
    public static final String TAGS = "tags";
    /** The roles field. */

### SuggestItem (Domain Entity)
Location: `src/main/java/org/codelibs/fess/suggest/entity/SuggestItem.java`

Core attributes: `text`, `timestamp`, `queryFreq`, `docFreq`, `userBoost`, `readings`, `tags`, `roles`, `languages`, `kinds`

Kind types: `DOCUMENT`, `QUERY`, `USER`

---

## Development Workflow

### Build Commands

```bash
mvn compile                              # Compile

    extends AbstractFuture<V> {
  /*
   * In the GWT versions of the methods (below), every exceptionType parameter is required to be
   * Class<Throwable>. To handle only certain kinds of exceptions under GWT, you'll need to write
   * your own instanceof tests.
   */

  public final FluentFuture<V> catching(
      Class<Throwable> exceptionType,
      Function<? super Throwable, ? extends V> fallback,

    }

    public MaxCodePoint(String userFriendly) {
      value = decode(userFriendly);
    }
  }

  /**
   * The default values of maxCodePoint below provide pretty good performance models of different
   * kinds of common human text.
   *
   * @see MaxCodePoint#decode
   */
  @Param({"0x80", "0x90", "0x100", "0x800", "0x10000", "0x10ffff"})
  MaxCodePoint maxCodePoint;

  @Param({"16384"})
  int charCount;