}

        private static class WindowBucket {
            private volatile long requestCount = 0;
            private volatile long failureCount = 0;
            private volatile long totalResponseTime = 0;
            private volatile long minResponseTime = Long.MAX_VALUE;
            private volatile long maxResponseTime = 0;
            private volatile long lastUpdateTime = System.currentTimeMillis();

  static final Object NULL = new Object();

  static final LazyLogger log = new LazyLogger(AbstractFuture.class);

  static final boolean GENERATE_CANCELLATION_CAUSES = false;

  private volatile @Nullable Object value;

  private volatile @Nullable Listener listeners;

    private final Settings settings;

    private final boolean expand;

    private long reloadInterval = 0;

    private final Environment env;

    private volatile long lastModified;

    private volatile long lastChecked;

    private volatile SynonymMap synonymMap;

    public SynonymLoader(final Environment env, final Settings settings, final boolean expand, final Analyzer analyzer) {
        this.env = env;

      implements Supplier<T>, Serializable {
    private transient Object lock = new Object();

    final Supplier<T> delegate;
    transient volatile boolean initialized;
    // "value" does not need to be volatile; visibility piggy-backs
    // on volatile read of "initialized".
    transient @Nullable T value;

    MemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    protected volatile Map<String, Map<String, AccessResultImpl<Long>>> sessionMap = new HashMap<>();

    /** Map of session IDs to include URL patterns for filtering URLs. */
    protected volatile Map<String, List<Pattern>> includeUrlPatternMap = new HashMap<>();

    /** Map of session IDs to exclude URL patterns for filtering URLs. */

      implements Supplier<T>, Serializable {
    private transient Object lock = new Object();

    final Supplier<T> delegate;
    transient volatile boolean initialized;
    // "value" does not need to be volatile; visibility piggy-backs
    // on volatile read of "initialized".
    transient @Nullable T value;

    MemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    private volatile boolean includeStackTrace = false;
    private volatile Severity minLogLevel = Severity.INFO;

    // Performance optimization for sensitive data masking
    private volatile boolean enableHighPerformanceMode = false;
    private volatile boolean skipMaskingForDebugLevel = false;

    // Rate limiting
    private final Map<String, AtomicLong> rateLimitCounters = new ConcurrentHashMap<>();

    private final Smb2LeaseKey leaseKey;
    private final long createTime;
    private volatile long lastUpdateTime;
    private volatile long lastAccessTime;

    private final ConcurrentHashMap<String, FileInfo> children;
    private final ReadWriteLock lock;

    private volatile boolean isComplete;
    private volatile boolean hasChanges;
    private DirectoryCacheScope scope;
    private long maxAge;

    private static final int SALT_SIZE = 32;
    private static final int PBKDF2_ITERATIONS = 100_000;

    private final SecureRandom secureRandom = new SecureRandom();
    private volatile SecretKey masterKey;
    private volatile byte[] salt;
    private volatile boolean destroyed = false;

    /**
     * Initialize secure credential storage with a master password
     *
     * @param masterPassword the master password for encryption

   *
   * Note about volatile: volatile doesn't make it safe to read from a mutable graph in one thread
   * while writing to it in another. All it does is help with _reading_ from multiple threads
   * concurrently. For more information, see AbstractNetworkTest.concurrentIteration.
   */
  private transient volatile @Nullable Entry<K, V> cacheEntry;

  MapIteratorCache(Map<K, V> backingMap) {