<p>
A list of account ID and email address pairs of the AWS accounts that could not be processed.
</p>

@param unprocessedAccounts
A list of account ID and email address pairs of the AWS accounts that could not be processed.
546697
public void setUnprocessedAccounts(java.util.Collection<Result> unprocessedAccounts) {
        if (unprocessedAccounts == null) {
            this.unprocessedAccounts = null;
            return;
        }

        this.unprocessedAccounts = new java.util.ArrayList<Result>(unprocessedAccounts);
    }
1367299
func (s *GetMembersOutput) SetUnprocessedAccounts(v []*Result) *GetMembersOutput {
	s.UnprocessedAccounts = v
	return s
}
941310
synchronized void removeCredential(String accountId) throws IOException {
        DataStore<StoredCredential> sc = StoredCredential.getDefaultDataStore(dataStoreFactory);
        sc.delete(accountId);
        calendarService = null;
        geoService = null;
    }
37489
def get_unspent_outputs(addresses)
      validate_address(addresses)
      unspent = provider.list_unspent(addresses, @config[:min_confirmation], @config[:max_confirmation])
      result = unspent.map{|item|
        output_result = get_output(item['txid'], item['vout'])
        output_result.account = item['account']
        output = OpenAssets::Transaction::SpendableOutput.new(
          OpenAssets::Transaction::OutPoint.new(item['txid'], item['vout']), output_result)
        output.confirmations = item['confirmations']
        output.spendable = item['spendable']
        output.solvable = item['solvable']
        output
      }
      result
    end
579536
public void deleteMessages(final String accountReservationKey) {
		MailAccount mailAccount = checkNotNull(mailAccountManager.lookupUsedMailAccountForCurrentThread(accountReservationKey),
				"No mail account reserved for current thread under key '%s'", accountReservationKey);
		storeManagerFactory.create(mailAccount).deleteAllMessages();
	}
924518
public java.util.List<CancelSpotFleetRequestsErrorItem> getUnsuccessfulFleetRequests() {
        if (unsuccessfulFleetRequests == null) {
            unsuccessfulFleetRequests = new com.amazonaws.internal.SdkInternalList<CancelSpotFleetRequestsErrorItem>();
        }
        return unsuccessfulFleetRequests;
    }
291378
public List<CmsAccountInfo> getAccountInfos() {

        if (m_accountInfos == null) {
            return Collections.unmodifiableList(Arrays.asList(DEFAULT_ACCOUNT_INFOS));
        } else {
            return Collections.unmodifiableList(m_accountInfos);
        }
    }
55188
public void setAccountAliases(java.util.Collection<String> accountAliases) {
        if (accountAliases == null) {
            this.accountAliases = null;
            return;
        }

        this.accountAliases = new com.amazonaws.internal.SdkInternalList<String>(accountAliases);
    }
736783
@Override
	public void cacheResult(List<CommerceAccount> commerceAccounts) {
		for (CommerceAccount commerceAccount : commerceAccounts) {
			if (entityCache.getResult(
						CommerceAccountModelImpl.ENTITY_CACHE_ENABLED,
						CommerceAccountImpl.class,
						commerceAccount.getPrimaryKey()) == null) {
				cacheResult(commerceAccount);
			}
			else {
				commerceAccount.resetOriginalValues();
			}
		}
	}
463643
Map<Integer, Pair<ExecutionReference, ExecutableFlow>> fetchUnfinishedFlows()
      throws ExecutorManagerException {
    try {
      return this.dbOperator.query(FetchActiveExecutableFlows.FETCH_UNFINISHED_EXECUTABLE_FLOWS,
          new FetchActiveExecutableFlows());
    } catch (final SQLException e) {
      throw new ExecutorManagerException("Error fetching unfinished flows", e);
    }
  }
1221096
func (s *InviteMembersOutput) SetUnprocessedAccounts(v []*UnprocessedAccount) *InviteMembersOutput {
	s.UnprocessedAccounts = v
	return s
}
1186495
public void setUnprocessedNamedQueryIds(java.util.Collection<UnprocessedNamedQueryId> unprocessedNamedQueryIds) {
        if (unprocessedNamedQueryIds == null) {
            this.unprocessedNamedQueryIds = null;
            return;
        }

        this.unprocessedNamedQueryIds = new java.util.ArrayList<UnprocessedNamedQueryId>(unprocessedNamedQueryIds);
    }
940887
public static base_responses unset(nitro_service client, vpnclientlessaccessprofile resources[],  String[] args) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vpnclientlessaccessprofile unsetresources[] = new vpnclientlessaccessprofile[resources.length];
			for (int i=0;i<resources.length;i++){
				unsetresources[i] = new vpnclientlessaccessprofile();
				unsetresources[i].profilename = resources[i].profilename;
			}
			result = unset_bulk_request(client, unsetresources,args);
		}
		return result;
	}
396232
public ArrayList<OvhPrice> billingAccount_allowedCreditThreshold_GET(String billingAccount) throws IOException {
		String qPath = "/telephony/{billingAccount}/allowedCreditThreshold";
		StringBuilder sb = path(qPath, billingAccount);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, t17);
	}
675970
func (s *CreateMembersOutput) SetUnprocessedAccounts(v []*UnprocessedAccount) *CreateMembersOutput {
	s.UnprocessedAccounts = v
	return s
}
638204
protected Pair<Boolean, Set<Throwable>> evaluateAuthenticationPolicies(final Authentication authentication,
                                                                           final AuthenticationTransaction transaction,
                                                                           final Set<AuthenticationHandler> authenticationHandlers) {
        val failures = new LinkedHashSet<Throwable>();
        val policies = authenticationEventExecutionPlan.getAuthenticationPolicies(transaction);

        policies.forEach(p -> {
            try {
                val simpleName = p.getClass().getSimpleName();
                LOGGER.debug("Executing authentication policy [{}]", simpleName);
                val supportingHandlers = authenticationHandlers
                    .stream()
                    .filter(handler -> transaction.getCredentials().stream().anyMatch(handler::supports))
                    .collect(Collectors.toCollection(LinkedHashSet::new));
                if (!p.isSatisfiedBy(authentication, supportingHandlers)) {
                    failures.add(new AuthenticationException("Unable to satisfy authentication policy " + simpleName));
                }
            } catch (final GeneralSecurityException e) {
                LOGGER.debug(e.getMessage(), e);
                failures.add(e.getCause());
            } catch (final Exception e) {
                LOGGER.debug(e.getMessage(), e);
                failures.add(e);
            }
        });

        return Pair.of(failures.isEmpty(), failures);
    }
486313
public void setVerifiedEmailAddresses(java.util.Collection<String> verifiedEmailAddresses) {
        if (verifiedEmailAddresses == null) {
            this.verifiedEmailAddresses = null;
            return;
        }

        this.verifiedEmailAddresses = new com.amazonaws.internal.SdkInternalList<String>(verifiedEmailAddresses);
    }