}

    /**
     * Get cache entry for a directory
     *
     * @param directoryPath directory path
     * @return cache entry or null
     */
    public DirectoryCacheEntry getCacheEntry(String directoryPath) {
        DirectoryCacheEntry entry = directoryCache.get(directoryPath);

        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {

        private final Entry<K, V> entry;

        private Map1(K key, V value) {
            this.entry = new SimpleImmutableEntry<>(key, value);
        }

        @Override
        public Set<Entry<K, V>> entrySet() {
            return new AbstractImmutableSet<>() {
                @Override
                public Iterator<Entry<K, V>> iterator() {

  public @Nullable Entry<E> pollFirstEntry() {
    Iterator<Entry<E>> entryIterator = entryIterator();
    if (entryIterator.hasNext()) {
      Entry<E> result = entryIterator.next();
      result = Multisets.immutableEntry(result.getElement(), result.getCount());
      entryIterator.remove();
      return result;
    }
    return null;
  }

  @Override
  public @Nullable Entry<E> pollLastEntry() {

    /**
     * Adds user attributes to the LDAP entry for user creation.
     *
     * @param entry the BasicAttributes to add user attributes to
     * @param user the user object containing attribute values
     */
    protected void addUserAttributes(final BasicAttributes entry, final User user) {
        entry.put(new BasicAttribute("cn", user.getName()));

func (o *listPathOptions) shouldSkip(ctx context.Context, entry metaCacheEntry) (yes bool) {
	if !o.IncludeDirectories && (entry.isDir() || (!o.Versioned && entry.isObjectDir() && entry.isLatestDeletemarker())) {
		return true
	}
	if o.Marker != "" && entry.name < o.Marker {
		return true
	}
	if !strings.HasPrefix(entry.name, o.Prefix) {
		return true
	}

    /**
     * construct a single vertex
     */
    public MetadataGraph(MetadataGraphVertex entry) throws MetadataResolutionException {
        checkVertex(entry);
        checkVertices(1);

        entry.setCompareVersion(versionedVertices);
        entry.setCompareScope(scopedVertices);

        vertices.add(entry);
        this.entry = entry;
    }
    // ------------------------------------------------------------------------

        docMap.put("key1", "value1");
        docMap.put("key2", "value2");
        docMap.put("key3", "value3");

        Set<Map.Entry<String, Object>> entrySet = docMap.entrySet();
        assertEquals(3, entrySet.size());

        Set<Map.Entry<String, Object>> parentEntrySet = parentMap.entrySet();
        assertEquals(parentEntrySet, entrySet);
    }

    public void test_entrySet_with_lang_key() {

        final String servletPath = req.getServletPath();
        for (final Map.Entry<String, String> entry : encodingMap.entrySet()) {
            final String path = entry.getKey();
            if (servletPath.startsWith(path)) {
                req.setCharacterEncoding(entry.getValue());
                final StringBuilder locationBuf = new StringBuilder(1000);

    }

    /**
     * Retrieve a single character mapping entry by ID for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param id identifier of the mapping entry
     * @return JSON response containing the mapping entry
     */
    // GET /api/admin/dict/mapping/setting/{dictId}/{id}
    @Execute

            try (Stream<Path> stream = Files.list(logDirPath)) {
                stream.filter(entry -> isLogFilename(entry.getFileName().toString())).forEach(filePath -> {
                    final ZipEntry entry = new ZipEntry(id + "/" + filePath.getFileName().toString());
                    try {
                        zos.putNextEntry(entry);
                        final long len = Files.copy(filePath, zos);