<p>
An array of <a>ProductionVariantSummary</a> objects, one for each model hosted behind this endpoint.
</p>

@param productionVariants
An array of <a>ProductionVariantSummary</a> objects, one for each model hosted behind this endpoint.
556931
public void setProductionVariants(java.util.Collection<ProductionVariantSummary> productionVariants) {
        if (productionVariants == null) {
            this.productionVariants = null;
            return;
        }

        this.productionVariants = new java.util.ArrayList<ProductionVariantSummary>(productionVariants);
    }
328622
public App withEnvironmentVariables(java.util.Map<String, String> environmentVariables) {
        setEnvironmentVariables(environmentVariables);
        return this;
    }
1264183
public void setResourceTypes(java.util.Collection<String> resourceTypes) {
        if (resourceTypes == null) {
            this.resourceTypes = null;
            return;
        }

        this.resourceTypes = new java.util.ArrayList<String>(resourceTypes);
    }
385979
public void setVersions(java.util.Collection<String> versions) {
        if (versions == null) {
            this.versions = null;
            return;
        }

        this.versions = new java.util.ArrayList<String>(versions);
    }
981159
@Override
	public void initVariantProviderStrategy(GeneratorContext context, Map<String, VariantSet> variantsSetMap) {

		List<Map<String, String>> variantMapStrategies = new ArrayList<>();
		Map<String, String> ctxVariantMap = context.getVariantMap();
		VariantSet skinVariantSet = variantsSetMap.get(JawrConstant.SKIN_VARIANT_TYPE);
		String skinVariant = ctxVariantMap.get(JawrConstant.SKIN_VARIANT_TYPE);

		VariantSet localeVariantSet = variantsSetMap.get(JawrConstant.LOCALE_VARIANT_TYPE);
		String localeVariant = ctxVariantMap.get(JawrConstant.LOCALE_VARIANT_TYPE);

		variantMapStrategies.add(getVariantMap(skinVariant, localeVariant));
		if (localeVariantSet != null) {
			variantMapStrategies.add(getVariantMap(skinVariant, localeVariantSet.getDefaultVariant()));
		}
		variantMapStrategies.add(getVariantMap(skinVariantSet.getDefaultVariant(), localeVariant));
		if (localeVariantSet != null) {
			variantMapStrategies
					.add(getVariantMap(skinVariantSet.getDefaultVariant(), localeVariantSet.getDefaultVariant()));
		}

		variantMapStrategyIterator = variantMapStrategies.iterator();
	}
749528
public <T> BroadcastVariableMaterialization<T, ?> materializeBroadcastVariable(String name, int superstep, BatchTask<?, ?> holder,
			MutableReader<?> reader, TypeSerializerFactory<T> serializerFactory) throws IOException {
		final BroadcastVariableKey key = new BroadcastVariableKey(holder.getEnvironment().getJobVertexId(), name, superstep);

		while (true) {
			final BroadcastVariableMaterialization<T, Object> newMat = new BroadcastVariableMaterialization<T, Object>(key);

			final BroadcastVariableMaterialization<?, ?> previous = variables.putIfAbsent(key, newMat);

			@SuppressWarnings("unchecked")
			final BroadcastVariableMaterialization<T, ?> materialization = (previous == null) ? newMat : (BroadcastVariableMaterialization<T, ?>) previous;

			try {
				materialization.materializeVariable(reader, serializerFactory, holder);
				return materialization;
			}
			catch (MaterializationExpiredException e) {
				// concurrent release. as an optimization, try to replace the previous one with our version. otherwise we might spin for a while
				// until the releaser removes the variable
				// NOTE: This would also catch a bug prevented an expired materialization from ever being removed, so it acts as a future safeguard

				boolean replaceSuccessful = false;
				try {
					replaceSuccessful = variables.replace(key, materialization, newMat);
				}
				catch (Throwable t) {}

				if (replaceSuccessful) {
					try {
						newMat.materializeVariable(reader, serializerFactory, holder);
						return newMat;
					}
					catch (MaterializationExpiredException ee) {
						// can still happen in cases of extreme races and fast tasks
						// fall through the loop;
					}
				}
				// else fall through the loop
			}
		}
	}
1362265
@Override
	public String getAvailableVariant(String variant, VariantSet variantSet) {

		String connectionType = variantSet.getDefaultVariant();
		if (variantSet.contains(variant)) {
			connectionType = variant;
		}

		return connectionType;
	}
208885
def getVariantAnnotationSets(self, datasetId):
        
        # TODO this should be displayed per-variant set, not per dataset.
        variantAnnotationSets = []
        dataset = app.backend.getDataRepository().getDataset(datasetId)
        for variantSet in dataset.getVariantSets():
            variantAnnotationSets.extend(
                variantSet.getVariantAnnotationSets())
        return variantAnnotationSets
799271
@Override
    public T addAsResources(Package resourcePackage, String... resourceNames) throws IllegalArgumentException {
        Validate.notNull(resourcePackage, "ResourcePackage must be specified");
        Validate.notNullAndNoNullValues(resourceNames,
            "ResourceNames must be specified and can not container null values");
        for (String resourceName : resourceNames) {
            addAsResource(resourcePackage, resourceName);
        }
        return covarientReturn();
    }
1350067
public void setPolicyVersions(java.util.Collection<PolicyVersion> policyVersions) {
        if (policyVersions == null) {
            this.policyVersions = null;
            return;
        }

        this.policyVersions = new java.util.ArrayList<PolicyVersion>(policyVersions);
    }
997052
@Override
    public T addAsWebInfResources(final Package resourcePackage, final String... resourceNames)
        throws IllegalArgumentException {
        Validate.notNull(resourcePackage, "ResourcePackage must be specified");
        Validate.notNullAndNoNullValues(resourceNames,
            "ResourceNames must be specified and can not container null values");
        for (String resourceName : resourceNames) {
            addAsWebInfResource(resourcePackage, resourceName);
        }
        return covarientReturn();
    }
1163206
public void registerVariantResolver(String clazz) {

		VariantResolver resolver = (VariantResolver) ClassLoaderResourceUtils.buildObjectInstance(clazz);
		registerVariantResolver(resolver);
	}
871017
@Override
    public List<V> apply(List<Variant> variants) {
        List<V> gaVariants = new ArrayList<>(variants.size());

        for (Variant variant : variants) {
            String id = variant.toString();

            List<String> variantIds = new ArrayList<>(variant.getIds());

            for (StudyEntry study : variant.getStudies()) {
                List<String> alternates = new ArrayList<>(study.getSecondaryAlternatesAlleles().size() + 1);
                alternates.add(variant.getAlternate());
                alternates.addAll(study.getSecondaryAlternatesAlleles());

                //Optional
                Long time = 0L;

//                //Only required for "graph" mode
//                List<String> alleleIds = null;

                //VariableSet should be the study, the file, or be provided?
                String variantSetId = study.getStudyId();


                Map<String, List<String>> fileInfo = parseInfo(study.getFiles());
                List calls = parseCalls(null, study);

                Long start = Long.valueOf(to0BasedStart(variant.getStart())); // Ga4gh uses 0-based positions.
                Long end = Long.valueOf(variant.getEnd());                    // 0-based end does not change

                @SuppressWarnings("unchecked")
                V ga = (V) factory.newVariant(id, variantSetId, variantIds, time, time,
                        variant.getChromosome(), start, end, variant.getReference(), alternates, fileInfo, calls);

                gaVariants.add(ga);
            }
        }


        return gaVariants;
    }
123087
public UpdateAppRequest withEnvironmentVariables(java.util.Map<String, String> environmentVariables) {
        setEnvironmentVariables(environmentVariables);
        return this;
    }
978715
public void setConfigurationRecorders(java.util.Collection<ConfigurationRecorder> configurationRecorders) {
        if (configurationRecorders == null) {
            this.configurationRecorders = null;
            return;
        }

        this.configurationRecorders = new com.amazonaws.internal.SdkInternalList<ConfigurationRecorder>(configurationRecorders);
    }
254025
public void setConfigurationManagers(java.util.Collection<OperatingSystemConfigurationManager> configurationManagers) {
        if (configurationManagers == null) {
            this.configurationManagers = null;
            return;
        }

        this.configurationManagers = new com.amazonaws.internal.SdkInternalList<OperatingSystemConfigurationManager>(configurationManagers);
    }
456991
def insertVariantAnnotationSet(self, variantAnnotationSet):
        
        analysisJson = json.dumps(
            protocol.toJsonDict(variantAnnotationSet.getAnalysis()))
        try:
            models.Variantannotationset.create(
                id=variantAnnotationSet.getId(),
                variantsetid=variantAnnotationSet.getParentContainer().getId(),
                ontologyid=variantAnnotationSet.getOntology().getId(),
                name=variantAnnotationSet.getLocalId(),
                analysis=analysisJson,
                annotationtype=variantAnnotationSet.getAnnotationType(),
                created=variantAnnotationSet.getCreationTime(),
                updated=variantAnnotationSet.getUpdatedTime(),
                attributes=json.dumps(variantAnnotationSet.getAttributes()))
        except Exception as e:
            raise exceptions.RepoManagerException(e)