public void addIntHeader(String name, int value) {
        }

        @Override
        public java.util.Collection<String> getHeaders(String name) {
            return java.util.Collections.emptyList();
        }

        @Override
        public java.util.Collection<String> getHeaderNames() {
            return headers.keySet();
        }

        @Override

        if (synonymItemList == null) {
            reload(null);
        }

        if (offset >= synonymItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<SynonymItem> emptyList(), offset, size, synonymItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > synonymItemList.size()) {
            toIndex = synonymItemList.size();
        }

                }
            });
            return interfaces;
        } catch (Exception e) {
            log.warn("Failed to get network interfaces: {}", e.getMessage());
            return Collections.emptyList();
        }
    }

    private InetAddress getLocalAddressForInterface(NetworkInterface netInterface) {
        return netInterface.getInetAddresses().nextElement();
    }

    protected List<String> getDefaultGroupList() {
        final String value = ComponentUtil.getFessConfig().getSystemProperty("aad.default.groups");
        if (StringUtil.isBlank(value)) {
            return Collections.emptyList();
        }
        return split(value, ",").get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.toList()));
    }

    /**
     * Gets the default role list for users.

HSPLkotlin/collections/EmptyIterator;-><init>()V
HSPLkotlin/collections/EmptyIterator;->hasNext()Z
HSPLkotlin/collections/EmptyList;-><clinit>()V
HSPLkotlin/collections/EmptyList;-><init>()V
HSPLkotlin/collections/EmptyList;->isEmpty()Z
HSPLkotlin/collections/EmptyList;->iterator()Ljava/util/Iterator;
HSPLkotlin/collections/EmptyMap;-><clinit>()V
HSPLkotlin/collections/EmptyMap;-><init>()V

        @Override
        public List<AnalyzeToken> analyze(final String text, final String field, final String lang) {
            if (text == null || text.length() > maxContentLenth) {
                return Collections.emptyList();
            }
            final AnalyzeAction.Response analyzeResponse = client.admin()
                    .indices()
                    .prepareAnalyze(analyzerSettingsIndexName, text)

     */
    protected List<Pair<String, Pattern>> getClientRuleList(final String value) {
        if (StringUtil.isBlank(value)) {
            return Collections.emptyList();
        }
        return split(value, ",").get(stream -> stream.map(String::trim)//
                .map(s -> clientRuleCache.computeIfAbsent(s, t -> {
                    final String[] values = t.split(":", 2);

            }

            @Override
            public List<Map<String, Object>> getDocumentList(final String index, final SearchCondition<SearchRequestBuilder> condition) {
                return Collections.emptyList();
            }
        };
        ComponentUtil.register(client, "searchEngineClient");
        final DocList docList = new DocList();
        indexingHelper.sendDocuments(client, docList);

import static com.google.common.truth.Truth.assertThat;
import static java.lang.Math.min;
import static java.util.Arrays.asList;
import static java.util.Arrays.sort;
import static java.util.Collections.emptyList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Equivalence;

   * @param backingArray the array to back the list
   * @return a list view of the array
   */
  public static List<Long> asList(long... backingArray) {
    if (backingArray.length == 0) {
      return Collections.emptyList();
    }
    return new LongArrayAsList(backingArray);
  }

  private static final class LongArrayAsList extends AbstractList<Long>
      implements RandomAccess, Serializable {
    final long[] array;