userBhv.selectCursor(cb -> cb.query().setRoles_Equal(role.getId()), entity -> {
            entity.setRoles(
                    stream(entity.getRoles()).get(stream -> stream.filter(s -> !s.equals(role.getId())).toArray(n -> new String[n])));
            userBhv.insertOrUpdate(entity);
        });
    }

    /**
     * Sets up the list condition for the role query.
     * @param cb The role condition bean.

      }
    }
    return super.containsAll(collection);
  }

  @Override
  public Iterator<E> iterator() {
    return asList(contents).iterator();
  }

  @Override
  public @Nullable Object[] toArray() {
    @Nullable Object[] result = new @Nullable Object[contents.length];
    arraycopy(contents, 0, result, 0, contents.length);
    return result;
  }

  /*

     */
    protected SearchLogContext createSearchLogContext(final SearchRequestParams params, final FessConfig fessConfig) {
        final String[] roles = ComponentUtil.getRoleQueryHelper().build(params.getType()).stream().toArray(n -> new String[n]);
        final String userCode = fessConfig.isUserInfo() ? ComponentUtil.getUserInfoHelper().getUserCode() : null;

    if (elements.isEmpty()) {
      // We avoid allocating anything.
      return of();
    }
    // Collection<E>.toArray() is required to contain only E instances, and all we do is read them.
    // TODO(cpovirk): Consider using Object[] anyway.
    @SuppressWarnings("unchecked")
    E[] array = (E[]) elements.toArray();
    /*
     * For a Set, we guess that it contains no duplicates. That's just a guess for purpose of

    assertThat(joiner.join(set)).isEqualTo("");
    assertThat(joiner.join(set.iterator())).isEqualTo("");

    @Nullable Integer[] array = newArrayList(set).toArray(new @Nullable Integer[0]);
    assertThat(joiner.join(array)).isEqualTo("");

    StringBuilder sb1FromIterable = new StringBuilder();
    assertThat(joiner.appendTo(sb1FromIterable, set)).isSameInstanceAs(sb1FromIterable);

     *
     * @return an array of all unique file type values
     */
    public String[] getTypes() {
        return mimetypeMap.values().stream().distinct().toArray(n -> new String[n]);
    }

      } catch (UnsupportedOperationException expected) {
      }

      try {
        ((Collection<?>) multimap.asMap().values().toArray()[0]).clear();
        fail("asMap().values().toArray()[0].clear() succeeded on unmodifiable multimap");
      } catch (UnsupportedOperationException expected) {
      }
    }

    assertCollectionIsUnmodifiable(multimap.values(), sampleValue);

  public static <T extends @Nullable Object> T[] toArray(
      Iterable<? extends T> iterable, Class<@NonNull T> type) {
    return toArray(iterable, ObjectArrays.newArray(type, 0));
  }

  static <T extends @Nullable Object> T[] toArray(Iterable<? extends T> iterable, T[] array) {
    Collection<? extends T> collection = castOrCopyToCollection(iterable);
    return collection.toArray(array);
  }

  /**

        return split(permissionsText, "\n")
                .get(stream -> stream.map(permissionHelper::encode).filter(StringUtil::isNotBlank).distinct().toArray(String[]::new));
    }

    // ===================================================================================
    //                                                                            Document

    switch (size()) {
      case 0:
        return ImmutableList.of();
      case 1:
        return ImmutableList.of(iterator().next());
      default:
        return new RegularImmutableAsList<E>(this, toArray());
    }
  }

  /** If this collection is backed by an array of its elements in insertion order, returns it. */
  Object @Nullable [] internalArray() {
    return null;
  }

  /**