public static final String URL = "url";

    /** File passwords key for metadata */
    public static final String FILE_PASSWORDS = "file.passwords";

    /** Map containing metadata key-value pairs */
    protected Map<String, String[]> metadata = new HashMap<>();

    /** The extracted content text */
    protected String content;

    /**
     * Constructs a new ExtractData.
     */

                size += sizeOf(value);
            }
            return size;
        }
        if (obj instanceof Map<?, ?>) {
            long size = 0;
            for (final Map.Entry<?, ?> entry : ((Map<?, ?>) obj).entrySet()) {
                size += sizeOf(entry.getKey());
                size += sizeOf(entry.getValue());
            }
            return size;
        }

    Iterator<Entry<E>> entryIterator() {
      Iterator<Map.Entry<E, Integer>> backingEntries = backingMap.entrySet().iterator();
      return new UnmodifiableIterator<Multiset.Entry<E>>() {
        @Override
        public boolean hasNext() {
          return backingEntries.hasNext();
        }

        @Override
        public Multiset.Entry<E> next() {
          Map.Entry<E, Integer> mapEntry = backingEntries.next();

            }
        }, cleanupInterval, cleanupInterval, TimeUnit.MILLISECONDS);
    }

    /**
     * Get resource statistics
     *
     * @return map of statistics
     */
    public Map<String, Object> getStatistics() {
        long active = 0;
        long closed = 0;

        for (ResourceHolder holder : activeResources.values()) {
            if (holder.closed) {

pkg maps, func All[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq2[$1, $2] #61900
pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900

import java.util.concurrent.ConcurrentMap;
import org.jspecify.annotations.Nullable;

/**
 * A concurrent map which forwards all its method calls to another concurrent map. Subclasses should
 * override one or more methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

 */
abstract class AbstractUndirectedNetworkConnections<N, E> implements NetworkConnections<N, E> {
  /** Keys are edges incident to the origin node, values are the node at the other end. */
  final Map<E, N> incidentEdgeMap;

  AbstractUndirectedNetworkConnections(Map<E, N> incidentEdgeMap) {
    this.incidentEdgeMap = checkNotNull(incidentEdgeMap);
  }

  @Override
  public Set<N> predecessors() {
    return adjacentNodes();
  }

	tests := []struct {
		sizes []int64
		want  map[string]uint64
	}{
		{
			sizes: []int64{100, 1000, 72_000, 100_000},
			want: map[string]uint64{
				"LESS_THAN_1024_B":         2,
				"BETWEEN_64_KB_AND_256_KB": 2,
				"BETWEEN_1024B_AND_1_MB":   2,
			},
		},
		{
			sizes: []int64{100, 1000, 2000, 100_000, 13 * humanize.MiByte},
			want: map[string]uint64{
				"LESS_THAN_1024_B":         2,

    //                                                                              Source
    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (urlId != null) {
            addFieldToSource(sourceMap, "urlId", urlId);
        }
        if (docId != null) {

        final List<AccessToken> list = accessTokenService.getAccessTokenList(pager);
        return asJson(new ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                .total(pager.getAllRecordCount())
                .status(Status.OK)
                .result());
    }

    // GET /api/admin/accesstoken/setting/{id}