Refine search
@Override public Element selectElement(Element element) { Elements elements = element.select(selectorText); if (CollectionUtils.isNotEmpty(elements)) { return elements.get(0); } return null; }
/** * Null-safe check if the specified collection is not empty. * <p> * Null returns false. * * @param coll the collection to check, may be null * @return true if non-null and non-empty * @since Commons Collections 3.2 */ public static boolean isNotEmpty(Collection coll) { return !CollectionUtils.isEmpty(coll); }
/** * Delegates to {@link CollectionUtils#collect(Collection, Transformer)}, but performs the necessary type coercion * to allow the returned collection to be correctly casted based on the TypedTransformer. * * @param inputCollection * @param transformer * @return the typed, collected Collection */ @SuppressWarnings({ "unchecked", "rawtypes" }) public static <T> Collection<T> collect(Collection inputCollection, TypedTransformer<T> transformer) { return CollectionUtils.collect(inputCollection, transformer); }
private Pair<Boolean, Set<String>> hasOverlap(ArrayList<Set<String>> dimsList, Set<String> Dims) { Set<String> existing = new HashSet<>(); Set<String> overlap = new HashSet<>(); for (Set<String> dims : dimsList) { if (CollectionUtils.containsAny(existing, dims)) { overlap.addAll(ensureOrder(CollectionUtils.intersection(existing, dims))); } existing.addAll(dims); } return new Pair<>(overlap.size() > 0, overlap); }
public void testDisjunctionAsUnionMinusIntersection() { Collection dis = CollectionUtils.disjunction(collectionA,collectionB); Collection un = CollectionUtils.union(collectionA,collectionB); Collection inter = CollectionUtils.intersection(collectionA,collectionB); assertTrue(CollectionUtils.isEqualCollection(dis,CollectionUtils.subtract(un,inter))); }
@Override public void run() { try { List<String> servers = NamingProxy.getServers(); List<RaftPeer> peerList = new ArrayList<RaftPeer>(peers.allPeers()); List<String> oldServers = new ArrayList<String>(); if (CollectionUtils.isEmpty(servers)) { Loggers.RAFT.warn("get empty server list from address server,ignore it."); return; } for (RaftPeer peer : peerList) { oldServers.add(peer.ip); } List<String> newServers = (List<String>) CollectionUtils.subtract(servers, oldServers); if (!CollectionUtils.isEmpty(newServers)) { peers.add(newServers); Loggers.RAFT.info("server list is updated, new: {} servers: {}", newServers.size(), newServers); } List<String> deadServers = (List<String>) CollectionUtils.subtract(oldServers, servers); if (!CollectionUtils.isEmpty(deadServers)) { peers.remove(deadServers); Loggers.RAFT.info("server list is updated, dead: {}, servers: {}", deadServers.size(), deadServers); } } catch (Exception e) { Loggers.RAFT.info("error while updating server list.", e); } } }
if (StringUtils.isBlank(tableName)) { tableName = IdOverrideTableGenerator.DEFAULT_TABLE_NAME; if (StringUtils.isBlank(segmentColumnName)) { segmentColumnName = IdOverrideTableGenerator.DEFAULT_SEGMENT_COLUMN_NAME; if (StringUtils.isBlank(valueColumnName)) { valueColumnName = IdOverrideTableGenerator.DEFAULT_VALUE_COLUMN_NAME; boolean sequenceEntryExists = false; List results2 = em.createNativeQuery(sb2.toString()).getResultList(); if (CollectionUtils.isNotEmpty(results2) && results2.get(0) != null) { maxSequenceId = ((Number) results2.get(0)).longValue(); sequenceEntryExists = true; if (CollectionUtils.isNotEmpty(results) && results.get(0) != null) { LOG.debug(String.format("Checking for sequence corruption on entity %s", segmentValue)); Long maxEntityId = BLCNumberUtils.toLong(results.get(0));
public String build() { Preconditions.checkNotNull(fullTableName, "Table name cannot be null"); if (CollectionUtils.isEmpty(selectColumns) && StringUtils.isBlank(selectExpression)) { throw new IllegalArgumentException("At least one column or select expression must be provided"); if (StringUtils.isNotBlank(selectExpression)) { if (selectClauseBuilder.length()!=0) { selectClauseBuilder.append(" , "); if (StringUtils.isNotBlank(col)) { if ((first && selectClauseBuilder.length()!=0) || !first) { selectClauseBuilder.append(" , ");
checkProperty: { String mappingProperty = mapping.getFieldPath() == null ? null : mapping.getFieldPath().getTargetProperty(); if (StringUtils.isEmpty(mappingProperty)) { mappingProperty = mapping.getFullPropertyName(); if (!embeddedCollectionPath.getTargetProperty().equals(mappingProperty) && !StringUtils.isEmpty(mappingProperty)) { PredicateProvider predicateProvider = mapping.getRestriction().getPredicateProvider(); if (predicateProvider != null) { FilterValueConverter converter = mapping.getRestriction().getFilterValueConverter(); if (converter != null && CollectionUtils.isNotEmpty(mapping.getFilterValues())) { Object val = converter.convert(mapping.getFilterValues().get(0)); if (predicateProvider instanceof LikePredicateProvider) {
if (CollectionUtils.isEmpty(allAclRules)) { s_logger.debug(String.format("No ACL rules for [id=%s, name=%s]. Therefore, there is no need for consistency validation.", lockedAcl.getUuid(), lockedAcl.getName())); return; if (StringUtils.isBlank(aclConsistencyHash)) { User callingUser = CallContext.current().getCallingUser(); Account callingAccount = CallContext.current().getCallingAccount();
protected String determineRedirectUri(AuthorizationRequest authorizationRequest, String responseType, Client client) { List<String> uris = client.getRedirectUris(); String redirectUri = authorizationRequest.getRedirectUri(); if (StringUtils.isBlank(redirectUri)) { if (responseType.equals(IMPLICIT_GRANT_RESPONSE_TYPE)) { throw new ValidationResponseException(IMPLICIT_GRANT_REDIRECT_URI); } else if (CollectionUtils.isEmpty(uris)) { throw new ValidationResponseException(REDIRECT_URI_REQUIRED); } else { } else if (redirectUri.contains("#")) { throw new ValidationResponseException(REDIRECT_URI_FRAGMENT_COMPONENT); } else if (CollectionUtils.isNotEmpty(uris)) { boolean match = false; for (String uri : uris) {
@Override public boolean validateChecksum() { if (StringUtils.isBlank(getChecksum()) && CollectionUtils.isNotEmpty(metalinkChecksums)) { String chk = metalinkChecksums.get(random.nextInt(metalinkChecksums.size())); setChecksum(chk); s_logger.info("Checksum not provided but " + metalinkChecksums.size() + " found on metalink file, performing checksum using one of them: " + chk); } return super.validateChecksum(); } }
public static boolean validatePositionContractType(String name, String groupKeyCode, LocalDate asOfDate) { if (StringUtils.isNotEmpty(name) && asOfDate != null) { List<? extends PstnContractTypeContract> ptList = PmServiceLocator.getPstnContractTypeService().getPstnContractTypeList(name, groupKeyCode, asOfDate); return CollectionUtils.isNotEmpty(ptList); } return false; }
if (!isPartialUpgrade || CollectionUtils.isNotEmpty(sourceCidrList)) { networkACLItemVo.setSourceCidrList(sourceCidrList); if (!isPartialUpgrade || StringUtils.isNotBlank(protocol)) { networkACLItemVo.setProtocol(protocol); if (!isPartialUpgrade || StringUtils.isNotBlank(action)) { Action aclRuleAction = validateAndCreateNetworkAclRuleAction(action); networkACLItemVo.setAction(aclRuleAction); if (StringUtils.isNotBlank(customId)) { networkACLItemVo.setUuid(customId);
private TaskQuery addAssigneesToQuery(TaskQuery taskQuery, Map.Entry<ItemPath, Collection<? extends PrismValue>> assigneeFilter) { @SuppressWarnings("unchecked") Collection<PrismReferenceValue> assigneeRefs = (Collection<PrismReferenceValue>) assigneeFilter.getValue(); if (isEmpty(assigneeRefs)) { return taskQuery.taskUnassigned(); } else { List<String> values = MiscDataUtil.prismRefsToStrings(assigneeRefs); return taskQuery.taskInvolvedUser(StringUtils.join(values, ';')); } }
private boolean entityHeaderExists(List<AtlasEntityHeader> entityHeaders, String guid) { boolean ret = false; if (CollectionUtils.isNotEmpty(entityHeaders) && guid != null) { for (AtlasEntityHeader entityHeader : entityHeaders) { if (StringUtils.equals(entityHeader.getGuid(), guid)) { ret = true; break; } } } return ret; }
if (CollectionUtils.isEmpty(servers)) { return; if (!CollectionUtils.isEqualCollection(healthyList, newHealthyList)) {
private static void refreshSrvSiteIfNeed() { refreshSrvIfNeed(); try { if (System.currentTimeMillis() - lastSrvSiteRefreshTime > VIP_SRV_SITE_REF_INTER_MILLIS || !CollectionUtils.isEqualCollection(servers, lastServers)) { if (!CollectionUtils.isEqualCollection(servers, lastServers)) { Loggers.SRV_LOG.info("[REFRESH-SERVER-SITE] server list is changed, old: {}, new: {}", lastServers, servers); } lastServers = servers; } } catch (Exception e) { Loggers.SRV_LOG.warn("fail to query server site: ", e); } }
/** * Add an additional Map to the composite. * * @param map the Map to be added to the composite * @throws IllegalArgumentException if there is a key collision and there is no * MapMutator set to handle it. */ public synchronized void addComposited(Map map) throws IllegalArgumentException { for (int i = composite.length - 1; i >= 0; --i) { Collection intersect = CollectionUtils.intersection(this.composite[i].keySet(), map.keySet()); if (intersect.size() != 0) { if (this.mutator == null) { throw new IllegalArgumentException("Key collision adding Map to CompositeMap"); } else { this.mutator.resolveCollision(this, this.composite[i], map, intersect); } } } Map[] temp = new Map[this.composite.length + 1]; System.arraycopy(this.composite, 0, temp, 0, this.composite.length); temp[temp.length - 1] = map; this.composite = temp; }
Collections.sort(returnCategoryFacets, facetPositionComparator); final Collection<SearchFacet> facets = CollectionUtils.collect(returnCategoryFacets, new Transformer() { @Override public Object transform(Object input) { if (parentCategory != null && !categoryHierarchy.contains(parentCategory)) { parentFacets = parentCategory.getCumulativeSearchFacets(categoryHierarchy); CollectionUtils.filter(parentFacets, new Predicate() { @Override public boolean evaluate(Object arg) {