Adds a list of alias import results, and returns the key under which they were stored.<p>

@param importResults the alias import results

@return the key under which the alias import results were stored
433153
public synchronized String addImportResult(List<CmsAliasImportResult> importResults) {

        String key = (new CmsUUID()).toString();
        m_entries.put(key, importResults);
        return key;
    }
981203
public java.util.List<String> getImportTaskIds() {
        if (importTaskIds == null) {
            importTaskIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return importTaskIds;
    }
891092
public static ResultDescriptor ofResult(final Class<? extends AnalyzerResult> resultClass) {
        ResultDescriptor resultDescriptor = _resultDescriptors.get(resultClass);
        if (resultDescriptor == null) {
            resultDescriptor = new ResultDescriptorImpl(resultClass);
            _resultDescriptors.put(resultClass, resultDescriptor);
        }
        return resultDescriptor;
    }
27689
def GetExportedResult(self,
                        original_result,
                        converter,
                        metadata=None,
                        token=None):
    """"""

    exported_results = list(
        converter.Convert(
            metadata or ExportedMetadata(), original_result, token=token))

    if not exported_results:
      raise ExportError("Got 0 exported result when a single one "
                        "was expected.")

    if len(exported_results) > 1:
      raise ExportError("Got > 1 exported results when a single "
                        "one was expected, seems like a logical bug.")

    return exported_results[0]
1353359
List<String> generateImports(Set<String> importedTypes) {
        List<String> importDecls = new ArrayList<>();
        for (String it : importedTypes) {
            importDecls.add(StubKind.IMPORT.format(it));
        }
        return importDecls;
    }
113060
def add_on_results(self):
        
        if self._add_on_results is None:
            self._add_on_results = AddOnResultList(
                self._version,
                account_sid=self._solution['account_sid'],
                reference_sid=self._solution['sid'],
            )
        return self._add_on_results
1060340
Map<String, ClassName> suggestedImports() {
    Map<String, ClassName> result = new LinkedHashMap<>(importableTypes);
    result.keySet().removeAll(referencedNames);
    return result;
  }
100265
@Nonnull
	public Imports copyAndAdd(final Collection<Import> imports) {
		Check.notNull(imports, "imports");
		final List<Import> internal = Lists.newArrayList(imports);
		internal.addAll(imports);
		return new Imports(internal);
	}
457073
public void addObjectResult(ObjectResult objResult) {
        m_objResultList.add(objResult);
        
        // Elevate batch-level status to warning if needed.
        Status batchResult = getStatus();
        if (batchResult == Status.OK && objResult.getStatus() != ObjectResult.Status.OK) {
            setStatus(Status.WARNING);
        }
        if (objResult.isUpdated()) {
            setHasUpdates(true);
        }
    }
774556
public void addResult(CmsResourceTypeStatResult result) {

        if (!m_results.contains(result)) {
            m_results.add(result);
            m_updated = false;
        } else {
            m_results.remove(result);
            m_results.add(result);
            m_updated = true;
        }
    }
599584
private ResultSet generateKeysResultSet(final UpdateResult res) {
        if (this.generatedKeysColumnIndexes == null &&
            this.generatedKeysColumnNames == null) {

            return res.generatedKeys.resultSet().withStatement(this);
        } else if (this.generatedKeysColumnIndexes != null) {
            return res.generatedKeys.resultSet().withStatement(this).
                withProjection(this.generatedKeysColumnIndexes);

        } else {
            return res.generatedKeys.resultSet().withStatement(this).
                withProjection(this.generatedKeysColumnNames);
        }
    }
627087
public void setResults(java.util.Collection<String> results) {
        if (results == null) {
            this.results = null;
            return;
        }

        this.results = new com.amazonaws.internal.SdkInternalList<String>(results);
    }
688458
protected void addTypeNamesTags(StringBuilder resultString, Result result) {
		if (mergeTypeNamesTags) {
			// Produce a single tag with all the TypeName keys concatenated and all the values joined with '_'.
			String typeNameValues = TypeNameValuesStringBuilder.getDefaultBuilder().build(typeNames, result.getTypeName());
			addTag(resultString, StringUtils.join(typeNames, ""), typeNameValues);
		} else {
			Map<String, String> typeNameMap = TypeNameValue.extractMap(result.getTypeName());
			for (String oneTypeName : typeNames) {
				String value = typeNameMap.get(oneTypeName);
				if (value == null)
					value = "";
				addTag(resultString, oneTypeName, value);
			}
		}
	}
909023
private List<Data> getKeyValueSequence(Map<?, ?> entries) {
        if (entries == null || entries.isEmpty()) {
            return Collections.emptyList();
        }
        List<Data> keyValueSequence = new ArrayList<>(entries.size() * 2);
        for (Map.Entry<?, ?> entry : entries.entrySet()) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            Data dataKey = mapServiceContext.toData(key);
            Data dataValue = mapServiceContext.toData(value);
            keyValueSequence.add(dataKey);
            keyValueSequence.add(dataValue);
        }
        return keyValueSequence;
    }
771531
public java.util.List<String> getResults() {
        if (results == null) {
            results = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return results;
    }
994236
@Nonnull
	public Imports sortByName() {
		final List<Import> imports = Lists.newArrayList(this.imports);
		Collections.sort(imports, ORDER.nullsLast());
		return new Imports(imports);
	}
331007
@Nonnull
	public Imports copyAndAdd(final Imports imports) {
		Check.notNull(imports, "imports");
		return copyAndAdd(imports.asList());
	}