/** The sort order for displaying this duplicate host entry */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    /** The username of who created this duplicate host entry */
    @Size(max = 1000)
    public String createdBy;

    /** The timestamp when this duplicate host entry was created */
    @ValidateTypeFailure
    public Long createdTime;

package org.codelibs.core.collection;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * {@link HashMap} with an upper limit on the number of entries. When a new entry is added, the oldest entry is discarded using LRU if the limit is exceeded.
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

     */
    public SmbAuthentication get(final String path) {
        if (path == null) {
            return null;
        }

        for (final Map.Entry<String, SmbAuthentication> entry : authMap.entrySet()) {
            if (path.startsWith(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

 */
public class EditForm extends CreateForm {

    /** Unique identifier for the related query entry */
    @Required
    @Size(max = 1000)
    public String id;

    /** Username of the user who last updated this entry */
    @Size(max = 1000)
    public String updatedBy;

    /** Timestamp when this entry was last updated */
    @ValidateTypeFailure
    public Long updatedTime;

import com.google.errorprone.annotations.DoNotMock;
import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A map, each entry of which maps a {@link TypeToken} to an instance of that type. In addition to
 * implementing {@code Map}, the additional type-safe operations {@link #putInstance} and {@link
 * #getInstance} are available.
 *

import com.google.errorprone.annotations.DoNotMock;
import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A map, each entry of which maps a {@link TypeToken} to an instance of that type. In addition to
 * implementing {@code Map}, the additional type-safe operations {@link #putInstance} and {@link
 * #getInstance} are available.
 *

  }

  public void testToImmutableSortedMapMerging() {
    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
        toImmutableSortedMap(naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum);
    Equivalence<ImmutableMap<String, Integer>> equivalence =
        Equivalence.equals().<Entry<String, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
    CollectorTester.of(collector, equivalence)

    public Float boost;

    /** The username of who created this elevate word entry */
    @Size(max = 1000)
    public String createdBy;

    /** The timestamp when this elevate word entry was created */
    @ValidateTypeFailure
    public Long createdTime;

    /**
     * Initializes the form with default values for creating a new elevate word entry.
     */
    public void initialize() {
        boost = 100.0f;

    return CollectSpliterators.map(map.entrySet().spliterator(), Entry::getValue);
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && Iterators.contains(iterator(), object);
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  @Override
  public ImmutableList<V> asList() {
    ImmutableList<Entry<K, V>> entryList = map.entrySet().asList();

// lockRequesterInfo array or the whole array from the map (in case of a write lock
// or last read lock)
// UID and optionally owner must match for entries to be deleted.
func (l *localLocker) removeEntry(name string, args dsync.LockArgs, lri *[]lockRequesterInfo) bool {
	// Find correct entry to remove based on uid.
	for index, entry := range *lri {