<p>
An account limit structure that contain a list of AWS CloudFormation account limits and their values.
</p>

@param accountLimits
An account limit structure that contain a list of AWS CloudFormation account limits and their values.
348406
public void setAccountLimits(java.util.Collection<AccountLimit> accountLimits) {
        if (accountLimits == null) {
            this.accountLimits = null;
            return;
        }

        this.accountLimits = new com.amazonaws.internal.SdkInternalList<AccountLimit>(accountLimits);
    }
1365073
def _update_limits_from_api(self):
        
        logger.debug('Setting CloudFormation limits from API')
        self.connect()
        resp = self.conn.describe_account_limits()
        for lim in resp['AccountLimits']:
            if lim['Name'] == 'StackLimit':
                self.limits['Stacks']._set_api_limit(lim['Value'])
                continue
            logger.debug('API response contained unknown CloudFormation '
                         'limit: %s', lim['Name'])
216103
public com.google.privacy.dlp.v2.InspectConfig.FindingLimits getLimits() {
    return limits_ == null
        ? com.google.privacy.dlp.v2.InspectConfig.FindingLimits.getDefaultInstance()
        : limits_;
  }
177391
@com.fasterxml.jackson.annotation.JsonProperty("limitType")
    public void setLimitType(String limitType) {
        this.limitType = limitType;
    }
1034089
public void setAccountIds(java.util.Collection<String> accountIds) {
        if (accountIds == null) {
            this.accountIds = null;
            return;
        }

        this.accountIds = new java.util.ArrayList<String>(accountIds);
    }
442653
public String placeBatchLimitOrder(LimitOrder... limitOrders) throws IOException {
    if (limitOrders == null || limitOrders.length < 1) {
      throw new RuntimeException("this limitOrders not be null or length min 1");
    }
    if (limitOrders.length > 5) {
      throw new RuntimeException("this limitOrders length max 5");
    }
    List<Map<String, Object>> list = new ArrayList<>();
    Arrays.stream(limitOrders)
        .forEach(
            limitOrder -> {
              Map<String, Object> map = new HashMap<>();
              map.put("price", limitOrder.getLimitPrice().toPlainString());
              map.put("amount", limitOrder.getOriginalAmount().toPlainString());
              map.put("type", limitOrder.getType() == OrderType.BID ? "buy" : "sell");
              list.add(map);
            });

    ObjectMapper mapper = new ObjectMapper();
    String ordersData = mapper.writeValueAsString(list);

    OkCoinMoreTradeResult result =
        batchTrade(
            OkCoinAdapters.adaptSymbol(limitOrders[0].getCurrencyPair()),
            limitOrders[0].getType() == OrderType.BID ? "buy" : "sell",
            ordersData);
    StringBuilder builder = new StringBuilder();
    if (result.isStatus()) {
      result.getOrderInfo().stream()
          .forEach(
              p -> {
                if (-1L != Long.valueOf((long) p.get("order_id"))) {
                  builder.append(",").append((String) p.get("order_id"));
                }
              });
    }
    if (builder.length() > 1) {
      return builder.substring(1);
    } else {
      return "no one order success";
    }
  }
82091
public void setAccounts(java.util.Collection<Account> accounts) {
        if (accounts == null) {
            this.accounts = null;
            return;
        }

        this.accounts = new java.util.ArrayList<Account>(accounts);
    }
421448
def _update_limits_from_api(self):
        
        self.connect()
        logger.info("Querying EC2 DescribeAccountAttributes for limits")
        lims = self.conn.describe_account_limits()
        self.limits['Auto Scaling groups']._set_api_limit(
            lims['MaxNumberOfAutoScalingGroups'])
        self.limits['Launch configurations']._set_api_limit(
            lims['MaxNumberOfLaunchConfigurations'])
882897
func (s *GetAccountSettingsOutput) SetAccountLimit(v *AccountLimit) *GetAccountSettingsOutput {
	s.AccountLimit = v
	return s
}
395724
public void setLimitValues(java.util.Collection<String> limitValues) {
        if (limitValues == null) {
            this.limitValues = null;
            return;
        }

        this.limitValues = new java.util.ArrayList<String>(limitValues);
    }
269555
public List<StorageAccount> createStorageAccountsFrom(Element accounts) {
        List<StorageAccount> accts = new ArrayList<StorageAccount>();
        try {
            Iterator<?> accountList = accounts.getChildren().iterator();
            while (accountList.hasNext()) {
                Element accountXml = (Element) accountList.next();

                String type = accountXml.getChildText("storageProviderType");
                StorageProviderType acctType = StorageProviderType.fromString(
                    type);

                StorageAccountProviderBinding providerBinding = providerBindings
                    .get(acctType);
                if (null != providerBinding) {
                    accts.add(providerBinding.getAccountFromXml(accountXml));

                } else {
                    log.warn("Unexpected account type: " + acctType);
                }
            }

            // Make sure that there is at least one storage account
            if (accts.isEmpty()) {
                String error = "No storage accounts could be read";
                throw new StorageException(error);
            }

        } catch (Exception e) {
            String error = "Unable to build storage account information due " +
                           "to error: " + e.getMessage();
            log.error(error);
            throw new StorageException(error, e);
        }

        return accts;
    }
829312
func (s *DescribeAccountLimitsOutput) SetAccountLimits(v []*AccountLimit) *DescribeAccountLimitsOutput {
	s.AccountLimits = v
	return s
}
5530
func (c *client) applyAccountLimits() {
	if c.acc == nil || (c.kind != CLIENT && c.kind != LEAF) {
		return
	}

	// Set here, will need to fo checks for NoLimit.
	if c.acc.msubs != jwt.NoLimit {
		c.msubs = c.acc.msubs
	}
	if c.acc.mpay != jwt.NoLimit {
		c.mpay = c.acc.mpay
	}

	opts := c.srv.getOpts()

	// We check here if the server has an option set that is lower than the account limit.
	if c.mpay != jwt.NoLimit && opts.MaxPayload != 0 && int32(opts.MaxPayload) < c.acc.mpay {
		c.Errorf("Max Payload set to %d from server config which overrides %d from account claims", opts.MaxPayload, c.acc.mpay)
		c.mpay = int32(opts.MaxPayload)
	}

	// We check here if the server has an option set that is lower than the account limit.
	if c.msubs != jwt.NoLimit && opts.MaxSubs != 0 && opts.MaxSubs < int(c.acc.msubs) {
		c.Errorf("Max Subscriptions set to %d from server config which overrides %d from account claims", opts.MaxSubs, c.acc.msubs)
		c.msubs = int32(opts.MaxSubs)
	}

	if c.subsAtLimit() {
		go func() {
			c.maxSubsExceeded()
			time.Sleep(20 * time.Millisecond)
			c.closeConnection(MaxSubscriptionsExceeded)
		}()
	}
}
534932
public void setLimits(int maxConPerRoute, int maxConTotal) {
        this.maxConnPerRoute = maxConPerRoute;
        this.maxConnTotal = maxConTotal;
        if ( asyncHttpClient != null ) {
            try {
                asyncHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            asyncHttpClient = null;
        }
    }
1249411
@Nonnull
  public Query limit(int limit) {
    QueryOptions newOptions = new QueryOptions(options);
    newOptions.limit = limit;
    return new Query(firestore, path, newOptions);
  }
1261642
protected int handleGetLimit(int field, int limitType) {
        if (field == ERA) {
            if (limitType == MINIMUM || limitType == GREATEST_MINIMUM) {
                return BEFORE_MINGUO;
            } else {
                return MINGUO;
            }
        }
        return super.handleGetLimit(field, limitType);
    }
36158
private boolean incSlotLimit(JobInfo info, TaskType type, LimitType limit) {
    switch (limit) {
      case MIN:
        if (type == TaskType.MAP) {
          if (info.minMaps < runnableTasks(info, type)) {
            info.minMaps += 1;
            return true;
          }
        } else {
          if (info.minReduces < runnableTasks(info, type)) {
            info.minReduces += 1;
            return true;
          }
        }
        return false;
      case MAX:
        if (type == TaskType.MAP) {
          if (info.maxMaps < runnableTasks(info, type)) {
            info.maxMaps += 1;
            return true;
          }
        } else {
          if (info.maxReduces < runnableTasks(info, type)) {
            info.maxReduces += 1;
            return true;
          }
        }
        return false;
    }
    // Never come here
    return false;
  }