@Override
protected void configure() {
  LinkedBindingBuilder<Iterable<InetSocketAddress>> clusterBinder =
      bind(ServiceDiscoveryBindings.ZOO_KEEPER_CLUSTER_KEY);

  if (zooKeeperConfig.isInProcess()) {
    requireBinding(ShutdownRegistry.class);
    File tempDir = Files.createTempDir();
    bind(ZooKeeperTestServer.class).toInstance(new ZooKeeperTestServer(tempDir, tempDir));
    SchedulerServicesModule.addAppStartupServiceBinding(binder()).to(TestServerService.class);

    clusterBinder.toProvider(LocalZooKeeperClusterProvider.class).in(Singleton.class);
  } else {
    clusterBinder.toInstance(zooKeeperConfig.getServers());
  }

  install(new CuratorServiceDiscoveryModule(discoveryPath, zooKeeperConfig));
}
 

/**
 * Bind the given key to an {@link ElementParser<T>}, which will be applied to
 * the root {@link Element} of the {@link Document} at parse-time, and the
 * result bound in {@link MapScoped}.
 */
default <T> LinkedBindingBuilder<ElementParser<T>> bindRootElementParser(Key<T> key) {
    install(new ProvisionAtParseTime<>(key));
    bind(key).toProvider(new ResolvableType<RootElementParsingProvider<T>>(){}
                             .with(new TypeArgument<T>(key.getTypeLiteral()){}))
             .in(MapScoped.class);
    return bindElementParser(key);
}
 

/**
 * Binds individual flattened key-value properties in the configuration yml
 * file. So one can directly inject something like this:
 *
 * @Named("Hibernate.hibernate.jdbcDriver") String jdbcDriver OR
 * @Named("Dashboard.service.port") int port
 */
@SuppressWarnings({"rawtypes", "unchecked"})
private void bindConfigProperties() {
    bind(YamlConfiguration.class).toInstance(yamlConfiguration);
    Iterator<String> propertyKeys = yamlConfiguration.getKeys();
    while (propertyKeys.hasNext()) {
        String propertyKey = propertyKeys.next();
        Object propertyValue = yamlConfiguration.getProperty(propertyKey);
        LinkedBindingBuilder annotatedWith = bind(propertyValue.getClass()).annotatedWith(Names.named(propertyKey));
        annotatedWith.toInstance(propertyValue);
    }
}
 

@SuppressWarnings("unchecked")
private void bindValue(final LinkedBindingBuilder binding, final Object value) {
    if (value != null) {
        binding.toInstance(value);
    } else {
        binding.toProvider(Providers.of(null));
    }
}
 

public static LinkedBindingBuilder<ContainerRequestFilter> bindContainerRequestFilter(
  Binder binder
) {
  Multibinder<ContainerRequestFilter> requestFilterBinder = Multibinder.newSetBinder(
    binder,
    ContainerRequestFilter.class
  );
  return requestFilterBinder.addBinding();
}
 

public static LinkedBindingBuilder<SingularityClientCredentials> bindCredentials(
  Binder binder
) {
  return binder
    .bind(SingularityClientCredentials.class)
    .annotatedWith(Names.named(CREDENTIALS_PROPERTY_NAME));
}
 

protected void bindHealthCheck(LinkedBindingBuilder<HealthCheckHandler> bindingBuilder) {
    if (null != healthcheckHandlerClass) {
        bindingBuilder.to(healthcheckHandlerClass);
    } else {
        bindingBuilder.toInstance(healthcheckHandler);
    }
}
 

protected LinkedBindingBuilder<ArgumentResolverFactory<PlatformMessage, MessageBody>> addArgumentResolverBinding() {
	Preconditions.checkState(resolvers != null, "Must call super.configure() before calling addArgumentResolverBinding()");
	return resolvers.addBinding();
}
 

static public LinkedBindingBuilder<AmodeusDispatcher.AVDispatcherFactory> bindDispatcherFactory(Binder binder, String dispatcherName) {
    MapBinder<String, AmodeusDispatcher.AVDispatcherFactory> map = MapBinder.newMapBinder(binder, String.class, AmodeusDispatcher.AVDispatcherFactory.class);
    return map.addBinding(dispatcherName);
}
 

static public LinkedBindingBuilder<AmodeusGenerator.AVGeneratorFactory> bindGeneratorFactory(Binder binder, String generatorName) {
    MapBinder<String, AmodeusGenerator.AVGeneratorFactory> map = MapBinder.newMapBinder(binder, String.class, AmodeusGenerator.AVGeneratorFactory.class);
    return map.addBinding(generatorName);
}
 

static public LinkedBindingBuilder<AmodeusRouter.Factory> bindRouterFactory(Binder binder, String routerName) {
    MapBinder<String, AmodeusRouter.Factory> map = MapBinder.newMapBinder(binder, String.class, AmodeusRouter.Factory.class);
    return map.addBinding(routerName);
}
 

static public LinkedBindingBuilder<AmodeusInteractionFinder.AVInteractionFinderFactory> bindInteractionFinderFactory(Binder binder, String interactionFinderName) {
    MapBinder<String, AmodeusInteractionFinder.AVInteractionFinderFactory> map = MapBinder.newMapBinder(binder, String.class, AmodeusInteractionFinder.AVInteractionFinderFactory.class);
    return map.addBinding(interactionFinderName);
}
 

default <T> LinkedBindingBuilder<T> provisionAtParseTime(Key<T> key) {
    install(new ProvisionAtParseTime<>(key));
    return bind(key);
}
 

default <T> LinkedBindingBuilder<Parser<T>> bindParser(Key<T> key) {
    return bind(key.ofType(Types.parameterizedTypeLiteral(Parser.class, key.getTypeLiteral())));
}
 

default <T> LinkedBindingBuilder<Parser<T>> bindParser(TypeLiteral<T> type) {
    return bindParser(Key.get(type));
}
 

protected LinkedBindingBuilder<EurekaInstanceConfig> bindEurekaInstanceConfig() {
    return bind(EurekaInstanceConfig.class);
}
 

default <T> LinkedBindingBuilder<PrimitiveParser<T>> bindPrimitiveParser(Key<T> key) {
    final Key<PrimitiveParser<T>> parserKey = key.ofType(PrimitiveParser.typeOf(key.getTypeLiteral()));
    bindParser(key).to(parserKey);
    return bind(parserKey);
}
 

default <T> LinkedBindingBuilder<PrimitiveParser<T>> bindPrimitiveParser(TypeLiteral<T> type) {
    return bindPrimitiveParser(Key.get(type));
}
 

default <T> LinkedBindingBuilder<PrimitiveParser<T>> bindPrimitiveParser(Class<T> type) {
    return bindPrimitiveParser(Key.get(type));
}
 

default <T> LinkedBindingBuilder<ElementParser<T>> bindElementParser(Key<T> key) {
    final Key<ElementParser<T>> parserKey = key.ofType(new ResolvableType<ElementParser<T>>(){}.with(new TypeArgument<T>(key.getTypeLiteral()){}));
    bindParser(key).to(parserKey);
    return bind(parserKey);
}
 

default <T> LinkedBindingBuilder<ElementParser<T>> bindElementParser(TypeLiteral<T> type) {
    return bindElementParser(Key.get(type));
}
 

default <T> LinkedBindingBuilder<ElementParser<T>> bindElementParser(Class<T> type) {
    return bindElementParser(Key.get(type));
}
 

public <T> LinkedBindingBuilder<TargetedEventRouter<? super T>> bindEvent(Class<T> type) {
    return bindEvent(TypeLiteral.get(type));
}
 

public <T> LinkedBindingBuilder<TargetedEventRouter<? super T>> bindEvent(TypeLiteral<T> type) {
    return (LinkedBindingBuilder) typeMapBinder.addBinding(type);
}
 

private LinkedBindingBuilder rebind(Binding binding) {
    return binder.bind(binding.getKey());
}
 

public LinkedBindingBuilder<V> addBinding(Class<? extends K> type) {
    return addBinding(TypeToken.of(type));
}
 

public LinkedBindingBuilder<V> addBinding(TypeLiteral<? extends K> type) {
    return addBinding(Types.toToken(type));
}
 

public LinkedBindingBuilder<V> addBinding(TypeToken<? extends K> type) {
    return backingCollectionBinder.addBinding(type);
}
 

default <T> LinkedBindingBuilder<T> bindAndExpose(Key<T> key) {
    expose(key);
    return bind(key);
}
 

protected LinkedBindingBuilder<Action0> bindAfterShutdownAction() {
    return bind(Action0.class).annotatedWith(Names.named("afterShutdownAction"));
}