<p>
Collection of VPC peering connection records that match the request.
</p>

@param vpcPeeringConnections
Collection of VPC peering connection records that match the request.
326490
public void setVpcPeeringConnections(java.util.Collection<VpcPeeringConnection> vpcPeeringConnections) {
        if (vpcPeeringConnections == null) {
            this.vpcPeeringConnections = null;
            return;
        }

        this.vpcPeeringConnections = new java.util.ArrayList<VpcPeeringConnection>(vpcPeeringConnections);
    }
537882
public java.util.List<String> getVpcPeeringConnectionIds() {
        if (vpcPeeringConnectionIds == null) {
            vpcPeeringConnectionIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return vpcPeeringConnectionIds;
    }
401557
@Override
	public List<Connector> getSipConnectors() {
		List<Connector> connectors = new ArrayList<Connector>();
		
		Connector[] conns = service.findConnectors();
		
		for (Connector conn : conns) {
			if (conn.getProtocolHandler() instanceof SipProtocolHandler){
				connectors.add(conn);
			}
		}
		
		return connectors;
	}
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);
    }
777954
public void setDirectConnectGateways(java.util.Collection<DirectConnectGateway> directConnectGateways) {
        if (directConnectGateways == null) {
            this.directConnectGateways = null;
            return;
        }

        this.directConnectGateways = new com.amazonaws.internal.SdkInternalList<DirectConnectGateway>(directConnectGateways);
    }
1082818
private List<ConnectionFuture<StatefulRedisPubSubConnection<String, String>>> potentiallyConnectSentinels() {

        List<ConnectionFuture<StatefulRedisPubSubConnection<String, String>>> connectionFutures = new ArrayList<>();
        for (RedisURI sentinel : sentinels) {

            if (pubSubConnections.containsKey(sentinel)) {
                continue;
            }

            ConnectionFuture<StatefulRedisPubSubConnection<String, String>> future = redisClient.connectPubSubAsync(CODEC,
                    sentinel);
            pubSubConnections.put(sentinel, future);

            future.whenComplete((connection, throwable) -> {

                if (throwable != null || closed) {
                    pubSubConnections.remove(sentinel);
                }

                if (closed) {
                    connection.closeAsync();
                }
            });

            connectionFutures.add(future);
        }

        return connectionFutures;
    }
475710
public void setPrivateIpAddressConfigs(java.util.Collection<ScheduledInstancesPrivateIpAddressConfig> privateIpAddressConfigs) {
        if (privateIpAddressConfigs == null) {
            this.privateIpAddressConfigs = null;
            return;
        }

        this.privateIpAddressConfigs = new com.amazonaws.internal.SdkInternalList<ScheduledInstancesPrivateIpAddressConfig>(privateIpAddressConfigs);
    }
1115658
@Override
    public void openConnection(Map<String, String> properties) throws JdbcServerException {
        if (!endpointConfiguration.isAutoConnect()) {
            List<OpenConnection.Property> propertyList = convertToPropertyList(properties);
            handleMessageAndCheckResponse(JdbcMessage.openConnection(propertyList));
        }

        if (connections.get() == endpointConfiguration.getServerConfiguration().getMaxConnections()) {
            throw new JdbcServerException(String.format("Maximum number of connections (%s) reached",
                    endpointConfiguration.getServerConfiguration().getMaxConnections()));
        }

        connections.incrementAndGet();
    }
335292
public void setVpcAttachments(java.util.Collection<VpcAttachment> vpcAttachments) {
        if (vpcAttachments == null) {
            this.vpcAttachments = null;
            return;
        }

        this.vpcAttachments = new com.amazonaws.internal.SdkInternalList<VpcAttachment>(vpcAttachments);
    }
212558
def process_vpc_peering_connections_callback(aws_config, current_config, path, current_path, pc_id, callback_args):
    
    info = 'AccepterVpcInfo' if current_config['AccepterVpcInfo']['OwnerId'] == aws_config['aws_account_id'] else 'RequesterVpcInfo'
    region = current_path[current_path.index('regions')+1]
    vpc_id = current_config[info]['VpcId']
    target = aws_config['services']['vpc']['regions'][region]['vpcs'][vpc_id]
    manage_dictionary(target, 'peering_connections', [])
    if pc_id not in target['peering_connections']:
        target['peering_connections'].append(pc_id)

    # VPC information for the peer'd VPC
    current_config['peer_info'] = copy.deepcopy(current_config['AccepterVpcInfo' if info == 'RequesterVpcInfo' else 'RequesterVpcInfo'])
    if 'PeeringOptions' in current_config['peer_info']:
        current_config['peer_info'].pop('PeeringOptions')
    if 'organization' in aws_config and current_config['peer_info']['OwnerId'] in aws_config['organization']:
        current_config['peer_info']['name'] = aws_config['organization'][current_config['peer_info']['OwnerId']]['Name']
    else:
        current_config['peer_info']['name'] = current_config['peer_info']['OwnerId']
839877
public void setConnections(java.util.Collection<String> connections) {
        if (connections == null) {
            this.connections = null;
            return;
        }

        this.connections = new java.util.ArrayList<String>(connections);
    }
301852
@Override
    final public ManagedConnection matchManagedConnections(
                                                           final Set connectionSet, final Subject subject,
                                                           final ConnectionRequestInfo requestInfo) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "matchManagedConnections", new Object[] {
                                                                        connectionSet,
                                                                        JmsJcaManagedConnection.subjectToString(subject),
                                                                        requestInfo });
        }

        final SICoreConnection coreConnection = (requestInfo instanceof JmsJcaConnectionRequestInfo) ? ((JmsJcaConnectionRequestInfo) requestInfo)
                        .getSICoreConnection()
                        : null;

        final JmsJcaUserDetails userDetails = getUserDetails(subject,
                                                             requestInfo);

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {

            if (userDetails != null) {
                SibTr.debug(TRACE, "Got a username and password");
            } else {
                SibTr.debug(TRACE, "Using subject");
            }

        }

        JmsJcaManagedConnection matchedConnection = null;

        // Go through the set of managed connections and try and match one

        for (final Iterator iterator = connectionSet.iterator(); iterator
                        .hasNext();) {

            final Object object = iterator.next();

            // Skip over any non JmsJcaManagedConnections
            if (object instanceof JmsJcaManagedConnection) {

                final JmsJcaManagedConnection managedConnection = (JmsJcaManagedConnection) object;

                // If we have a user name and password from either the
                // requestInfo or subject then we must try and match againgst
                // those
                if (userDetails != null) {

                    if (managedConnection.match(userDetails, coreConnection)) {

                        matchedConnection = managedConnection;
                        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
                            SibTr
                                            .debug(TRACE,
                                                   "Matched a connection against the subject username and password");
                        }
                        break;

                    }

                } else {

                    // This is a subject where we couldnt get the userName and
                    // password from..

                    if (managedConnection.match(subject, coreConnection)) {

                        matchedConnection = managedConnection;
                        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
                            SibTr.debug(TRACE,
                                        "Matched a connection against the subject");
                        }
                        break;

                    }

                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "matchManagedConnections", matchedConnection);
        }
        return matchedConnection;

    }
502201
public java.util.List<VpcEndpointConnection> getVpcEndpointConnections() {
        if (vpcEndpointConnections == null) {
            vpcEndpointConnections = new com.amazonaws.internal.SdkInternalList<VpcEndpointConnection>();
        }
        return vpcEndpointConnections;
    }
215596
public Set<Integer> getConnections(String endpointId) {
        return Collections.unmodifiableSet(this.entries.get(endpointId));
    }
1370633
public void setVpcEndpoints(java.util.Collection<VpcEndpoint> vpcEndpoints) {
        if (vpcEndpoints == null) {
            this.vpcEndpoints = null;
            return;
        }

        this.vpcEndpoints = new com.amazonaws.internal.SdkInternalList<VpcEndpoint>(vpcEndpoints);
    }
1015090
public void primeConnections(List<Server> servers) {
        if (servers == null || servers.size() == 0) {
            logger.debug("No server to prime");
            return;
        }
        for (Server server: servers) {
            server.setReadyToServe(false);
        }
        int totalCount = (int) (servers.size() * primeRatio); 
        final CountDownLatch latch = new CountDownLatch(totalCount);
        final AtomicInteger successCount = new AtomicInteger(0);
        final AtomicInteger failureCount= new AtomicInteger(0);
        primeConnectionsAsync(servers, new PrimeConnectionListener()  {            
            @Override
            public void primeCompleted(Server s, Throwable lastException) {
                if (lastException == null) {
                    successCount.incrementAndGet();
                    s.setReadyToServe(true);
                } else {
                    failureCount.incrementAndGet();
                }
                latch.countDown();
            }
        }); 
                
        Stopwatch stopWatch = initialPrimeTimer.start();
        try {
            latch.await(maxTotalTimeToPrimeConnections, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            logger.error("Priming connection interrupted", e);
        } finally {
            stopWatch.stop();
        }

        stats = new PrimeConnectionEndStats(totalCount, successCount.get(), failureCount.get(), stopWatch.getDuration(TimeUnit.MILLISECONDS));

        printStats(stats);
    }
692601
public java.util.List<String> getVpnConnectionIds() {
        if (vpnConnectionIds == null) {
            vpnConnectionIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return vpnConnectionIds;
    }