return split(value, ",").get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).toArray(n -> new String[n]));
    }

    public static class OpenIdUser implements FessUser {

        private static final long serialVersionUID = 1L;

        protected final String name;

        protected String[] groups;

        protected String[] roles;

        protected String[] permissions;

    putByte((byte) i);
    putByte((byte) (i >>> 8));
    putByte((byte) (i >>> 16));
    putByte((byte) (i >>> 24));
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putLong(long l) {
    for (int i = 0; i < 64; i += 8) {
      putByte((byte) (l >>> i));
    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putChar(char c) {
    putByte((byte) c);

  }

  override fun isShutdown(): Boolean {
    return shutdown
  }

  override fun isTerminated(): Boolean {
    throw UnsupportedOperationException()
  }

  override fun awaitTermination(
    timeout: Long,
    unit: TimeUnit,
  ): Boolean {
    throw UnsupportedOperationException()
  }

    private byte securityFlags;
    private byte requestedOplockLevel = SMB2_OPLOCK_LEVEL_NONE;
    private int impersonationLevel = SMB2_IMPERSONATION_LEVEL_IMPERSONATION;
    private long smbCreateFlags;
    private int desiredAccess = 0x00120089; // 0x80000000 | 0x1;
    private int fileAttributes;
    private int shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
    private int createDisposition = FILE_OPEN;

        private Boolean explain;

        private Float minScore;

        private String preference;

        private String routing;

        private String searchType;

        private long timeoutInMillis = -1;

        private Boolean version;

        private Boolean seqNoAndPrimaryTerm = Boolean.TRUE;

        private int terminateAfter = 0;

   * connection if `streamId` is zero.
   */
  @Throws(IOException::class)
  fun windowUpdate(
    streamId: Int,
    windowSizeIncrement: Long,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(windowSizeIncrement != 0L && windowSizeIncrement <= 0x7fffffffL) {

			Name:     "bar",
			Linkname: "PAX4/PAX4/long-linkpath-name",
			ModTime:  time.Unix(0, 0),
			Typeflag: '2',
			PAXRecords: map[string]string{
				"linkpath": "PAX4/PAX4/long-linkpath-name",
			},
			Format: FormatPAX,
		}},
	}, {
		// Both BSD and GNU tar truncate long names at first NUL even
		// if there is data following that NUL character.
		// This is reasonable as GNU long names are C-strings.

   *     State#TERMINATED} when this method is called then this will throw an IllegalStateException.
   * @since 15.0
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException;

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#TERMINATED terminated state}.
   *

        return STEMMER_OVERRIDE;
    }

    @Override
    public String getPath() {
        return path;
    }

    @Override
    public synchronized OptionalEntity<StemmerOverrideItem> get(final long id) {
        if (stemmerOverrideItemList == null) {
            reload(null);
        }

        for (final StemmerOverrideItem stemmerOverrideItem : stemmerOverrideItemList) {

        Object writeReplace() {
          return super.writeReplace();
        }
      };
    } else {
      return super.createAsList();
    }
  }

  @Override
  public int size() {
    long distance = domain.distance(first(), last());
    return (distance >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) distance + 1;
  }

  @Override
  public boolean contains(@CheckForNull Object object) {