<p>
Launch configurations for server groups in the application.
</p>

@param serverGroupLaunchConfigurations
Launch configurations for server groups in the application.
331631
public void setServerGroupLaunchConfigurations(java.util.Collection<ServerGroupLaunchConfiguration> serverGroupLaunchConfigurations) {
        if (serverGroupLaunchConfigurations == null) {
            this.serverGroupLaunchConfigurations = null;
            return;
        }

        this.serverGroupLaunchConfigurations = new java.util.ArrayList<ServerGroupLaunchConfiguration>(serverGroupLaunchConfigurations);
    }
1010382
func (s *GetAppLaunchConfigurationOutput) SetServerGroupLaunchConfigurations(v []*ServerGroupLaunchConfiguration) *GetAppLaunchConfigurationOutput {
	s.ServerGroupLaunchConfigurations = v
	return s
}
747416
public void setRootGroups(final List<Group> rootGroups)
    {
        synchronized(this.getRootGroups())
        {
            if(rootGroups != this.getRootGroups())
            {
                this.getRootGroups().clear();
                
                if(rootGroups != null)
                {
                    this.getRootGroups().addAll(rootGroups);
                }
            }
        }
    }
1300655
protected void updateLaunchOptionsFromConfig(ILaunchConfiguration config) {
		final boolean showLogo = this.accessor.getShowLogoFlag(config);
		final boolean showLogInfo = this.accessor.getShowLogInfoFlag(config);
		final boolean offline = this.accessor.getOfflineFlag(config);
		final boolean runInEclipse = this.accessor.isEmbeddedSRE(config);
		final boolean enableAssertionsRun = this.accessor.isAssertionEnabledInRunMode(config);
		final boolean enableAssertionsDebug = this.accessor.isAssertionEnabledInDebugMode(config);
		this.showLogoOptionButton.setSelection(showLogo);
		this.showLogInfoButton.setSelection(showLogInfo);
		this.offlineButton.setSelection(offline);
		this.enableAssertionsInRunModeButton.setSelection(enableAssertionsRun);
		this.enableAssertionsInDebugModeButton.setSelection(enableAssertionsDebug);
		this.runInEclipseButton.setSelection(runInEclipse);
	}
1043863
public java.util.List<LaunchConfiguration> getLaunchConfigurations() {
        if (launchConfigurations == null) {
            launchConfigurations = new com.amazonaws.internal.SdkInternalList<LaunchConfiguration>();
        }
        return launchConfigurations;
    }
260785
function (project) {
			if (project) {
				this._projectClient.getProjectLaunchConfigurations(project).then(function(launchConfigurations){
					if (project !== this._project) return;
					this._setLaunchConfigurations(launchConfigurations);
				}.bind(this));
			} else {
				this._setLaunchConfigurations(null);
			}
		}
495322
public void setTargetGroups(java.util.Collection<TargetGroup> targetGroups) {
        if (targetGroups == null) {
            this.targetGroups = null;
            return;
        }

        this.targetGroups = new java.util.ArrayList<TargetGroup>(targetGroups);
    }
1095512
public void setCacheSecurityGroups(java.util.Collection<CacheSecurityGroup> cacheSecurityGroups) {
        if (cacheSecurityGroups == null) {
            this.cacheSecurityGroups = null;
            return;
        }

        this.cacheSecurityGroups = new com.amazonaws.internal.SdkInternalList<CacheSecurityGroup>(cacheSecurityGroups);
    }
1217046
private void populateServerGroupResults(final OperationContext context, final Map<ServerIdentity, ModelNode> serverResults) {

        final Set<String> groupNames = new TreeSet<String>();
        final Map<String, Set<HostServer>> groupToServerMap = new HashMap<String, Set<HostServer>>();
        for (Map.Entry<ServerIdentity, ModelNode> entry : serverResults.entrySet()) {
            final String serverGroup = entry.getKey().getServerGroupName();
            groupNames.add(serverGroup);
            final String hostName = entry.getKey().getHostName();
            final String serverName = entry.getKey().getServerName();
            if (!groupToServerMap.containsKey(serverGroup)) {
                groupToServerMap.put(serverGroup, new TreeSet<HostServer>());
            }
            groupToServerMap.get(serverGroup).add(new HostServer(hostName, serverName, entry.getValue()));
        }

        boolean serverGroupSuccess = false;
        ModelNode failureReport = new ModelNode();
        for (String groupName : groupNames) {
            final ModelNode groupNode = new ModelNode();
            boolean groupFailure = multiphaseContext.isServerGroupRollback(groupName);
            if (groupFailure) {
                // TODO revisit if we should report this for the whole group, since the result might not be accurate
                // groupNode.get(ROLLED_BACK).set(true);
            } else {
                serverGroupSuccess = true;
            }
            for (HostServer hostServer : groupToServerMap.get(groupName)) {
                final ModelNode hostResult = hostServer.result.clone();
                if(hostResult.hasDefined(RESPONSE_HEADERS)){
                    final ModelNode responseHeaders = hostResult.get(RESPONSE_HEADERS);
                    if(responseHeaders.hasDefined(WARNINGS)){
                        responseHeaders.remove(WARNINGS);
                    }
                    if(responseHeaders.keys().size() == 0){
                        hostResult.remove(RESPONSE_HEADERS);
                    }
                }
                groupNode.get(HOST, hostServer.hostName, hostServer.serverName, RESPONSE).set(hostResult);
                if (groupFailure && hostResult.hasDefined(OUTCOME)
                        && FAILED.equals(hostResult.get(OUTCOME).asString())
                        && hostResult.hasDefined(FAILURE_DESCRIPTION)) {
                    ModelNode failDesc = hostResult.get(FAILURE_DESCRIPTION);
                    if (!CompositeOperationHandler.getUnexplainedFailureMessage().equals(failDesc.asString())) {
                        failureReport.get(SERVER_GROUP, groupName, HOST, hostServer.hostName, hostServer.serverName).set(failDesc);
                    } // else the server just reported an unexplained composite failure.
                      // We assume it's due to domain-wide rollback, which is not useful information
                      // so don't include this server in the top level failure description
                }
            }
            context.getServerResults().get(groupName).set(groupNode);
        }
        if (!serverGroupSuccess) {
            if (failureReport.isDefined()) {
                ModelNode fullFailure = new ModelNode();
                fullFailure.get(DomainControllerLogger.HOST_CONTROLLER_LOGGER.operationFailedOrRolledBackWithCause()).set(failureReport);
                context.getFailureDescription().set(fullFailure);
            } else {
                context.getFailureDescription().set(DomainControllerLogger.HOST_CONTROLLER_LOGGER.operationFailedOrRolledBack());
            }
        }
    }
56756
protected void onApplicationConfigurations()
	{
		// set configuration before the application configuration...
		onBeforeApplicationConfigurations();
		// set global configurations for both development and deployment mode...
		onGlobalSettings();
		// set configuration for development...
		if (RuntimeConfigurationType.DEVELOPMENT.equals(this.getConfigurationType()))
		{
			onDevelopmentModeSettings();
		}
		// set configuration for deployment...
		if (RuntimeConfigurationType.DEPLOYMENT.equals(this.getConfigurationType()))
		{
			onDeploymentModeSettings();
		}
	}
259344
public void setServers(java.util.Collection<ListedServer> servers) {
        if (servers == null) {
            this.servers = null;
            return;
        }

        this.servers = new java.util.ArrayList<ListedServer>(servers);
    }
1221459
public void setGroups(java.util.Collection<SegmentGroup> groups) {
        if (groups == null) {
            this.groups = null;
            return;
        }

        this.groups = new java.util.ArrayList<SegmentGroup>(groups);
    }
753100
public Deployment setServerGroups(final Collection<String> serverGroups) {
        this.serverGroups.clear();
        this.serverGroups.addAll(serverGroups);
        return this;
    }
164495
public void setDBParameterGroups(java.util.Collection<DBParameterGroupStatus> dBParameterGroups) {
        if (dBParameterGroups == null) {
            this.dBParameterGroups = null;
            return;
        }

        this.dBParameterGroups = new java.util.ArrayList<DBParameterGroupStatus>(dBParameterGroups);
    }
459570
public void setLaunchTemplates(java.util.Collection<LaunchTemplate> launchTemplates) {
        if (launchTemplates == null) {
            this.launchTemplates = null;
            return;
        }

        this.launchTemplates = new com.amazonaws.internal.SdkInternalList<LaunchTemplate>(launchTemplates);
    }
782731
public void setConfigurations(java.util.Collection<MatchmakingConfiguration> configurations) {
        if (configurations == null) {
            this.configurations = null;
            return;
        }

        this.configurations = new java.util.ArrayList<MatchmakingConfiguration>(configurations);
    }
893242
public void setParameterGroups(java.util.Collection<ClusterParameterGroup> parameterGroups) {
        if (parameterGroups == null) {
            this.parameterGroups = null;
            return;
        }

        this.parameterGroups = new com.amazonaws.internal.SdkInternalList<ClusterParameterGroup>(parameterGroups);
    }