<p>
The existing Amazon VPC prefixes advertised to the Direct Connect gateway.
</p>

@param existingAllowedPrefixesToDirectConnectGateway
The existing Amazon VPC prefixes advertised to the Direct Connect gateway.
505139
public void setExistingAllowedPrefixesToDirectConnectGateway(java.util.Collection<RouteFilterPrefix> existingAllowedPrefixesToDirectConnectGateway) {
        if (existingAllowedPrefixesToDirectConnectGateway == null) {
            this.existingAllowedPrefixesToDirectConnectGateway = null;
            return;
        }

        this.existingAllowedPrefixesToDirectConnectGateway = new com.amazonaws.internal.SdkInternalList<RouteFilterPrefix>(
                existingAllowedPrefixesToDirectConnectGateway);
    }
1124584
public java.util.List<InternetGateway> getInternetGateways() {
        if (internetGateways == null) {
            internetGateways = new com.amazonaws.internal.SdkInternalList<InternetGateway>();
        }
        return internetGateways;
    }
42919
def detectCustomImportPaths(self, prefix):
		
		for assignment in self.ip2pp_mapping:
			if prefix.startswith(assignment["ipprefix"]):
				return {"prefix": assignment["ipprefix"], "provider_prefix": assignment["provider_prefix"]}

		return {}
191873
public java.util.List<String> getEgressOnlyInternetGatewayIds() {
        if (egressOnlyInternetGatewayIds == null) {
            egressOnlyInternetGatewayIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return egressOnlyInternetGatewayIds;
    }
841529
public void setEgressOnlyInternetGateways(java.util.Collection<EgressOnlyInternetGateway> egressOnlyInternetGateways) {
        if (egressOnlyInternetGateways == null) {
            this.egressOnlyInternetGateways = null;
            return;
        }

        this.egressOnlyInternetGateways = new com.amazonaws.internal.SdkInternalList<EgressOnlyInternetGateway>(egressOnlyInternetGateways);
    }
405341
public void setEgressOnlyInternetGatewayIds(java.util.Collection<String> egressOnlyInternetGatewayIds) {
        if (egressOnlyInternetGatewayIds == null) {
            this.egressOnlyInternetGatewayIds = null;
            return;
        }

        this.egressOnlyInternetGatewayIds = new com.amazonaws.internal.SdkInternalList<String>(egressOnlyInternetGatewayIds);
    }
948713
public void setCustomerGatewayIds(java.util.Collection<String> customerGatewayIds) {
        if (customerGatewayIds == null) {
            this.customerGatewayIds = null;
            return;
        }

        this.customerGatewayIds = new com.amazonaws.internal.SdkInternalList<String>(customerGatewayIds);
    }
685540
func (s *GatewayAssociationProposal) SetExistingAllowedPrefixesToDirectConnectGateway(v []*RouteFilterPrefix) *GatewayAssociationProposal {
	s.ExistingAllowedPrefixesToDirectConnectGateway = v
	return s
}
30505
@Deprecated
    public void setPrefix(String prefix) {
        if (prefix == null) {
            throw new IllegalArgumentException(
                    "Prefix cannot be null for a replication rule");
        }
        if (filter != null) {
            throw new IllegalArgumentException(
                    "You cannot use both prefix and filter at the same time in a replication rule");
        }
        this.prefix = prefix;
    }
1073452
protected <T extends AbstractResource> void addStandardHeaders(URLConnection con, T resource) {
		con.setRequestProperty("User-Agent", userAgent);
		con.setRequestProperty("Accept", resource.getAcceptedTypes());
	}
580433
public void setAddAllowedPrefixesToDirectConnectGateway(java.util.Collection<RouteFilterPrefix> addAllowedPrefixesToDirectConnectGateway) {
        if (addAllowedPrefixesToDirectConnectGateway == null) {
            this.addAllowedPrefixesToDirectConnectGateway = null;
            return;
        }

        this.addAllowedPrefixesToDirectConnectGateway = new com.amazonaws.internal.SdkInternalList<RouteFilterPrefix>(addAllowedPrefixesToDirectConnectGateway);
    }
1152775
protected void connectionBuilder(Mono<SocketAddress> socketAddressSupplier, ConnectionBuilder connectionBuilder,
            RedisURI redisURI) {

        Bootstrap redisBootstrap = new Bootstrap();
        redisBootstrap.option(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, 32 * 1024);
        redisBootstrap.option(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, 8 * 1024);
        redisBootstrap.option(ChannelOption.ALLOCATOR, BUF_ALLOCATOR);

        SocketOptions socketOptions = getOptions().getSocketOptions();

        redisBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS,
                Math.toIntExact(socketOptions.getConnectTimeout().toMillis()));

        if (LettuceStrings.isEmpty(redisURI.getSocket())) {
            redisBootstrap.option(ChannelOption.SO_KEEPALIVE, socketOptions.isKeepAlive());
            redisBootstrap.option(ChannelOption.TCP_NODELAY, socketOptions.isTcpNoDelay());
        }

        connectionBuilder.timeout(redisURI.getTimeout());
        connectionBuilder.password(redisURI.getPassword());

        connectionBuilder.bootstrap(redisBootstrap);
        connectionBuilder.channelGroup(channels).connectionEvents(connectionEvents).timer(timer);
        connectionBuilder.socketAddressSupplier(socketAddressSupplier);
    }
35889
public java.util.List<VirtualGateway> getVirtualGateways() {
        if (virtualGateways == null) {
            virtualGateways = new com.amazonaws.internal.SdkInternalList<VirtualGateway>();
        }
        return virtualGateways;
    }
339603
public CORSConfigBuilder withAllowedOrigins(Collection<String> allowedOrigins) {
        if (allowedOrigins != null) {
            for (String allowedOrigin : allowedOrigins) {
                if (!allowedOrigin.startsWith("http://") && !allowedOrigin.startsWith("https://")) {
                    throw new IllegalArgumentException(allowedOrigin + " is invalid: origins much have an http:// or https:// prefix");
                }
                if (allowedOrigin.lastIndexOf('/') > 8) {
                    throw new IllegalArgumentException(allowedOrigin + " is invalid: origins should not have any paths. Example origin: https://example.org");
                }
            }
        }
        this.allowedOrigins = allowedOrigins;
        return this;
    }
1134990
public void setDirectConnectGatewayAttachments(java.util.Collection<DirectConnectGatewayAttachment> directConnectGatewayAttachments) {
        if (directConnectGatewayAttachments == null) {
            this.directConnectGatewayAttachments = null;
            return;
        }

        this.directConnectGatewayAttachments = new com.amazonaws.internal.SdkInternalList<DirectConnectGatewayAttachment>(directConnectGatewayAttachments);
    }
246414
public void addAllowedPrefix(String prefix) {
        if (prefix.endsWith(".")) {
            prefix = prefix.substring(0, prefix.length() - 1);
        }
        LOG.debug("Allowed prefix: {}", prefix);
        String packageRegex = START + dotsToRegex(prefix) + SEP;
        LOG.debug("Prefix regex: {}", packageRegex);
        patternList.add(Pattern.compile(packageRegex).matcher(""));
    }
1171952
@SuppressWarnings("unchecked")
    protected <K, V, T extends RedisChannelHandler<K, V>> ConnectionFuture<T> initializeChannelAsync(
            ConnectionBuilder connectionBuilder) {

        Mono<SocketAddress> socketAddressSupplier = connectionBuilder.socketAddress();

        if (clientResources.eventExecutorGroup().isShuttingDown()) {
            throw new IllegalStateException("Cannot connect, Event executor group is terminated.");
        }

        CompletableFuture<SocketAddress> socketAddressFuture = new CompletableFuture<>();
        CompletableFuture<Channel> channelReadyFuture = new CompletableFuture<>();

        socketAddressSupplier.doOnError(socketAddressFuture::completeExceptionally).doOnNext(socketAddressFuture::complete)
                .subscribe(redisAddress -> {

                    if (channelReadyFuture.isCancelled()) {
                        return;
                    }
                    initializeChannelAsync0(connectionBuilder, channelReadyFuture, redisAddress);
                }, channelReadyFuture::completeExceptionally);

        return new DefaultConnectionFuture<>(socketAddressFuture, channelReadyFuture.thenApply(channel -> (T) connectionBuilder
                .connection()));
    }