}
      next = CompactHashing.getNext(entry, mask);
    } while (next != UNSET);
    return -1;
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    return (delegate != null) ? delegate.containsKey(key) : indexOf(key) != -1;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();

    public boolean isEmpty() {
      synchronized (mutex) {
        return delegate().isEmpty();
      }
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      synchronized (mutex) {
        return delegate().containsKey(key);
      }
    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      synchronized (mutex) {

    public boolean isEmpty() {
      synchronized (mutex) {
        return delegate().isEmpty();
      }
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      synchronized (mutex) {
        return delegate().containsKey(key);
      }
    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      synchronized (mutex) {

            matchedLabelSet.stream().forEach(newLabelSet::add);
            dataMap.put(fessConfig.getIndexFieldLabel(), newLabelSet.toArray(new String[newLabelSet.size()]));
        }

        if (!dataMap.containsKey(fessConfig.getIndexFieldDocId())) {
            dataMap.put(fessConfig.getIndexFieldDocId(), systemHelper.generateDocId(dataMap));
        }

        ComponentUtil.getLanguageHelper().updateDocument(dataMap);

              parameterTypes[0].getName(),
              Primitives.wrap(parameterTypes[0]).getSimpleName());

          MethodIdentifier ident = new MethodIdentifier(method);
          if (!identifiers.containsKey(ident)) {
            identifiers.put(ident, method);
          }
        }
      }
    }
    return ImmutableList.copyOf(identifiers.values());
  }

    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override
          Map<String, String> wrap(HashMap<String, String> map) {
            if (map.containsKey(null)) {
              throw new NullPointerException();
            }
            return new AbstractMap<String, String>() {
              @Override
              public Set<Entry<String, String>> entrySet() {

   */
  @Override
  public ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys) {
    Map<K, V> result = new LinkedHashMap<>();
    for (Object key : keys) {
      if (!result.containsKey(key)) {
        @SuppressWarnings("unchecked")
        K castKey = (K) key;
        V value = getIfPresent(key);
        if (value != null) {
          result.put(castKey, value);
        }
      }
    }

     *
     * @param directoryPath directory path
     * @param leaseKey lease key
     */
    public void startWatching(String directoryPath, Smb2LeaseKey leaseKey) {
        if (activeWatchers.containsKey(directoryPath)) {
            return; // Already watching
        }

        try {
            SmbFile directory = new SmbFile(directoryPath, leaseManager.getContext());

     */
    public boolean hasChild(String name) {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return children.containsKey(name);
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Check if cache entry is expired
     *
     * @return true if expired
     */

        }
    }
    
    public boolean hasChild(String name) {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return children.containsKey(name);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public boolean isExpired() {
        return System.currentTimeMillis() - lastUpdateTime > maxAge;
    }