<p>
List of servers belonging to a server group.
</p>

@param serverList
List of servers belonging to a server group.
515759
public void setServerList(java.util.Collection<Server> serverList) {
        if (serverList == null) {
            this.serverList = null;
            return;
        }

        this.serverList = new java.util.ArrayList<Server>(serverList);
    }
892699
Map<String, CmsSSLMode> getWebserverList() {

        Map<String, CmsSSLMode> ret = new LinkedHashMap<String, CmsSSLMode>();
        for (I_CmsEditableGroupRow row : m_workplaceServerGroup.getRows()) {
            CmsWorkplaceServerWidget widget = (CmsWorkplaceServerWidget)row.getComponent();
            ret.put(widget.getServer(), widget.getSSLMode());
        }
        return ret;
    }
349528
private List<ServerConnection> updateServerList() {
        final Map<Endpoint, ServerConnection> allServersByEndpoint = allServers
                .stream()
                .collect(toImmutableMap(ServerConnection::endpoint,
                                        Function.identity(),
                                        (l, r) -> l));
        return allServers = delegate
                .endpoints()
                .stream()
                .map(endpoint -> {
                    ServerConnection connection = allServersByEndpoint.get(endpoint);
                    if (connection != null) {
                        return connection;
                    }
                    return new ServerConnection(endpoint, createEndpointHealthChecker(endpoint));
                })
                .collect(toImmutableList());
    }
279973
public void setSAMLProviderList(java.util.Collection<SAMLProviderListEntry> sAMLProviderList) {
        if (sAMLProviderList == null) {
            this.sAMLProviderList = null;
            return;
        }

        this.sAMLProviderList = new com.amazonaws.internal.SdkInternalList<SAMLProviderListEntry>(sAMLProviderList);
    }
1091599
public List<ServerRedirect> tableServers(int clientId) {
        List<ServerRedirect> servers = new ArrayList<>();

        try {
            Client client = ClientService.getInstance().getClient(clientId);
            servers = tableServers(client.getProfile().getId(), client.getActiveServerGroup());
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return servers;
    }
606936
public java.util.List<ServerCertificateMetadata> getServerCertificateMetadataList() {
        if (serverCertificateMetadataList == null) {
            serverCertificateMetadataList = new com.amazonaws.internal.SdkInternalList<ServerCertificateMetadata>();
        }
        return serverCertificateMetadataList;
    }
353314
public void setSourceIdsList(java.util.Collection<String> sourceIdsList) {
        if (sourceIdsList == null) {
            this.sourceIdsList = null;
            return;
        }

        this.sourceIdsList = new com.amazonaws.internal.SdkInternalList<String>(sourceIdsList);
    }
1317073
public void setClusterInfoList(java.util.Collection<ClusterInfo> clusterInfoList) {
        if (clusterInfoList == null) {
            this.clusterInfoList = null;
            return;
        }

        this.clusterInfoList = new java.util.ArrayList<ClusterInfo>(clusterInfoList);
    }
100110
static public <E> LoadBalancedList<E> synchronizedList(LoadBalancedList<E> list) {
        return new ConcurrentLoadBalancedList<E>(list);
    }
209165
@CheckReturnValue
	@VisibleForTesting
	ImmutableList<Server> mergeServerLists(List<Server> firstList, List<Server> secondList) {
		ImmutableList.Builder<Server> results = ImmutableList.builder();
		List<Server> toProcess = new ArrayList<>(secondList);
		for (Server firstServer : firstList) {
			if (toProcess.contains(firstServer)) {
				Server found = toProcess.get(secondList.indexOf(firstServer));
				results.add(merge(firstServer, found));
				// remove server as it is already merged
				toProcess.remove(found);
			} else {
				results.add(firstServer);
			}
		}
		// add servers from the second list that are not in the first one
		results.addAll(toProcess);
		return results.build();
	}
1180415
public void setInstanceInformationList(java.util.Collection<InstanceInformation> instanceInformationList) {
        if (instanceInformationList == null) {
            this.instanceInformationList = null;
            return;
        }

        this.instanceInformationList = new com.amazonaws.internal.SdkInternalList<InstanceInformation>(instanceInformationList);
    }
490649
public Collection<Server> list(String name)
    {
        List<Server> ret = new ArrayList<Server>();
        Collection<Server> servers = list();
        for(Server server : servers)
        {
            if(name == null || server.getName().equals(name))
                ret.add(server);
        }
        return ret;
    }
302266
public OperationFuture<List<Server>> removeAutoscalePolicyOnServer(List<Server> serverList) {
        List<JobFuture> jobs = serverList
            .stream()
            .map(server -> removeAutoscalePolicyOnServer(server).jobFuture())
            .collect(toList());

        return
            new OperationFuture<>(
                serverList,
                new ParallelJobsFuture(jobs)
            );
    }
739350
public void setConnectionNameList(java.util.Collection<String> connectionNameList) {
        if (connectionNameList == null) {
            this.connectionNameList = null;
            return;
        }

        this.connectionNameList = new java.util.ArrayList<String>(connectionNameList);
    }
301026
public void setCaseIdList(java.util.Collection<String> caseIdList) {
        if (caseIdList == null) {
            this.caseIdList = null;
            return;
        }

        this.caseIdList = new com.amazonaws.internal.SdkInternalList<String>(caseIdList);
    }
336259
public void addScannerServers(final int query_index, final int id, 
      final Set<String> servers) {
    Map<Integer, Set<String>> query_servers = scanner_servers.get(query_index);
    if (query_servers == null) {
      query_servers = new ConcurrentHashMap<Integer, Set<String>>(
          Const.SALT_WIDTH() > 0 ? Const.SALT_BUCKETS() : 1);
      scanner_servers.put(query_index, query_servers);
    }
    query_servers.put(id, servers);
  }
1126920
public final void addServer(String hostList) throws IOException {
    Map<InetSocketAddress, InetSocketAddress> addresses = AddrUtil.getAddressMap(hostList);
    if (addresses != null && addresses.size() > 0) {
      for (Map.Entry<InetSocketAddress, InetSocketAddress> entry : addresses.entrySet()) {
        final InetSocketAddress mainNodeAddr = entry.getKey();
        final InetSocketAddress standbyNodeAddr = entry.getValue();
        this.connect(new InetSocketAddressWrapper(mainNodeAddr,
            this.serverOrderCount.incrementAndGet(), 1, null));
        if (standbyNodeAddr != null) {
          this.connect(new InetSocketAddressWrapper(standbyNodeAddr,
              this.serverOrderCount.incrementAndGet(), 1, mainNodeAddr));
        }
      }
    }
  }