public static class RefreshDependenciesOption extends EnabledOnlyBooleanBuildOption<StartParameterInternal> {
        public RefreshDependenciesOption() {
            super(null, CommandLineOptionConfiguration.create("refresh-dependencies", "U", "Refresh the state of dependencies."));
        }

        @Override
        public void applyTo(StartParameterInternal settings, Origin origin) {
            settings.setRefreshDependencies(true);
        }

	switch cfg.Name {
	case storageclass.STANDARD, storageclass.RRS:
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, errTierReservedName), r.URL)
		return
	}

	// Refresh from the disk in case we had missed notifications about edits from peers.
	if err := globalTierConfigMgr.Reload(ctx, objAPI); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

      }
    }
    return ImmutableMap.copyOf(result);
  }

  @Override
  public final V apply(K key) {
    return getUnchecked(key);
  }

  @Override
  public void refresh(K key) {
    throw new UnsupportedOperationException();
  }

        }
    }

    protected RefreshResponse refresh() {
        try {
            return getClient().get(c -> c.admin().indices().prepareRefresh(index).execute());
        } catch (final Exception e) {
            throw new EsAccessException("Failed to refresh.", e);
        }
    }

    protected IndexResponse insert(final Object target, final OpType opType) {

        : expireAfterAccessNanos;
  }

  /**
   * Specifies that active entries are eligible for automatic refresh once a fixed duration has
   * elapsed after the entry's creation, or the most recent replacement of its value. The semantics
   * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link
   * CacheLoader#reload}.
   *

      }
    }
    return ImmutableMap.copyOf(result);
  }

  @Override
  public final V apply(K key) {
    return getUnchecked(key);
  }

  @Override
  public void refresh(K key) {
    throw new UnsupportedOperationException();
  }

        core.rootMetaData.allowGetOrHead()
        util.allowAll()

        if (resolveDynamic) {
            mavenHttpRepo.module('org.readonly', 'core', '0.9').publish()
            executer.withArgument("--refresh-dependencies")
        }

        succeeds ':checkDeps', ':extraArtifacts'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {

            }
            return permissions;
        }

        @Override
        public boolean refresh() {
            if (authResult.getExpiresAfter() < ComponentUtil.getSystemHelper().getCurrentTimeAsLong()) {
                return false;
            }

import org.gradle.api.logging.Logging;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * RetryHttpInitializerWrapper will automatically retry upon RPC failures, preserving the
 * auto-refresh behavior of the Google Credentials.
 *
 * Adapted from https://github.com/GoogleCloudPlatform/java-docs-samples,
 * available under <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache 2.0</a> license.
 */

			e.base.time = r.lastTs + 1
		}
		r.lastTs = e.base.time
	}()

	// Consume any events in the ordering first.
	if ev, ok := r.order.Next(); ok {
		return ev, nil
	}

	// Check if we need to refresh the generation.
	if len(r.frontier) == 0 && len(r.cpuSamples) == 0 {
		if !r.emittedSync {
			r.emittedSync = true
			return syncEvent(r.gen.evTable, r.lastTs), nil
		}
		if r.spillErr != nil {