Example usage for org.apache.commons.collections4 CollectionUtils isNotEmpty

List of usage examples for org.apache.commons.collections4 CollectionUtils isNotEmpty

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections4.*
  5. CollectionUtils
  6. isNotEmpty

Introduction

In this page you can find the example usage for org.apache.commons.collections4 CollectionUtils isNotEmpty.

Prototype

public static boolean isNotEmpty(final Collection<?> coll)

Source Link

Document

Null-safe check if the specified collection is not empty.

Usage

From source file:com.epam.catgenome.dao.index.FeatureIndexDao.java

private void setSorting(List<VcfFilterForm.OrderBy> orderBy, GroupingSearch groupingSearch,
        List<? extends FeatureFile> files) throws IOException {
    if (CollectionUtils.isNotEmpty(orderBy)) {
        ArrayList<SortField> sortFields = new ArrayList<>();
        for (VcfFilterForm.OrderBy o : orderBy) {
            IndexSortField sortField = IndexSortField.getByName(o.getField());
            if (sortField == null) {
                VcfFilterInfo info = vcfManager
                        .getFiltersInfo(files.stream().map(BaseEntity::getId).collect(Collectors.toList()));

                InfoItem infoItem = info.getInfoItemMap().get(o.getField());
                Assert.notNull(infoItem, "Unknown sort field: " + o.getField());

                SortField.Type type = determineSortType(infoItem);
                SortField sf = new SortField(infoItem.getName().toLowerCase(), type, o.isDesc());
                setMissingValuesOrder(sf, type, o.isDesc());

                sortFields.add(sf);//from  w ww.  j a  va  2  s  .  c  om
            } else {
                SortField sf = new SortField(sortField.getField().fieldName, sortField.getType(), o.isDesc());
                setMissingValuesOrder(sf, sortField.getType(), o.isDesc());

                sortFields.add(sf);
            }
        }

        groupingSearch.setGroupSort(new Sort(sortFields.toArray(new SortField[sortFields.size()])));
    }
}

From source file:io.github.swagger2markup.internal.document.builder.PathsDocumentBuilder.java

/**
 * Builds the security section of a Swagger Operation.
 *
 * @param operation  the Swagger Operation
 * @param docBuilder the MarkupDocBuilder document builder
 *///from   w w w .  ja  va2 s.c om
private void buildSecuritySchemeSection(PathOperation operation, MarkupDocBuilder docBuilder) {
    List<Map<String, List<String>>> securitySchemes = operation.getOperation().getSecurity();

    MarkupDocBuilder securityBuilder = copyMarkupDocBuilder();
    applyPathsDocumentExtension(new Context(Position.OPERATION_SECURITY_BEGIN, securityBuilder, operation));
    if (CollectionUtils.isNotEmpty(securitySchemes)) {

        Map<String, SecuritySchemeDefinition> securityDefinitions = globalContext.getSwagger()
                .getSecurityDefinitions();
        List<List<String>> cells = new ArrayList<>();
        List<MarkupTableColumn> cols = Arrays.asList(
                new MarkupTableColumn(TYPE_COLUMN).withWidthRatio(3).withHeaderColumn(false)
                        .withMarkupSpecifiers(MarkupLanguage.ASCIIDOC, ".^3"),
                new MarkupTableColumn(NAME_COLUMN).withWidthRatio(4).withHeaderColumn(false)
                        .withMarkupSpecifiers(MarkupLanguage.ASCIIDOC, ".^4"),
                new MarkupTableColumn(SCOPES_COLUMN).withWidthRatio(13)
                        .withMarkupSpecifiers(MarkupLanguage.ASCIIDOC, ".^13"));
        for (Map<String, List<String>> securityScheme : securitySchemes) {
            for (Map.Entry<String, List<String>> securityEntry : securityScheme.entrySet()) {
                String securityKey = securityEntry.getKey();
                String type = UNKNOWN;
                if (securityDefinitions != null && securityDefinitions.containsKey(securityKey)) {
                    type = securityDefinitions.get(securityKey).getType();
                }

                List<String> content = Arrays.asList(boldText(type), boldText(copyMarkupDocBuilder()
                        .crossReference(securityDocumentResolver(), securityKey, securityKey).toString()),
                        Joiner.on(",").join(securityEntry.getValue()));
                cells.add(content);
            }
        }
        securityBuilder.tableWithColumnSpecs(cols, cells);
    }
    applyPathsDocumentExtension(new Context(Position.OPERATION_SECURITY_END, securityBuilder, operation));
    String securityContent = securityBuilder.toString();

    applyPathsDocumentExtension(new Context(Position.OPERATION_SECURITY_BEFORE, docBuilder, operation));
    if (isNotBlank(securityContent)) {
        buildSectionTitle(SECURITY, docBuilder);
        docBuilder.text(securityContent);
    }
    applyPathsDocumentExtension(new Context(Position.OPERATION_SECURITY_AFTER, docBuilder, operation));
}

From source file:com.epam.catgenome.manager.gene.GffManager.java

private List<GeneLowLevel> recursiveConvert(final Gene gene,
        final Map<Gene, List<ProteinSequenceEntry>> aminoAcids) {
    if (gene == null || CollectionUtils.isEmpty(gene.getItems())) {
        return Collections.emptyList();
    }/* w w w . j  ava 2s . co m*/

    final List<GeneLowLevel> items = new ArrayList<>();
    for (Gene item : gene.getItems()) {
        final GeneLowLevel geneLowLevel = new GeneLowLevel(item);
        items.add(geneLowLevel);

        setProteinSequences(aminoAcids, item, geneLowLevel);

        final List<GeneLowLevel> lows = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(item.getItems())) {
            for (Gene lowItem : item.getItems()) {
                final GeneLowLevel itemLowLevel = new GeneLowLevel(lowItem);
                itemLowLevel.setItems(recursiveConvert(lowItem, aminoAcids));
                lows.add(itemLowLevel);
            }
        }

        geneLowLevel.setItems(lows);
    }

    return items;
}

From source file:com.epam.catgenome.manager.gene.GffManager.java

private void setProteinSequences(final Map<Gene, List<ProteinSequenceEntry>> aminoAcids, Gene item,
        GeneLowLevel geneLowLevel) {/*from w  w  w .j  a va  2s  .c  o  m*/
    if (MapUtils.isNotEmpty(aminoAcids) && GeneUtils.isTranscript(item)) {
        final List<ProteinSequenceEntry> psEntryList = aminoAcids.get(item);
        if (CollectionUtils.isNotEmpty(psEntryList)) {
            List<ProteinSequence> psList = psEntryList.stream().map(ProteinSequence::new)
                    .collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(psList)) {
                geneLowLevel.setPsList(psList);
            }
        }
    }
}

From source file:com.haulmont.cuba.gui.data.impl.CollectionPropertyDatasourceImpl.java

@Override
public int indexOfId(K itemId) {
    if (itemId == null)
        return -1;
    Collection<T> collection = getCollection();
    if (CollectionUtils.isNotEmpty(collection)) {
        List<T> list = new ArrayList<>(collection);
        T currentItem = getItem(itemId);
        return list.indexOf(currentItem);
    }// w  ww  .  j  a v a 2s. c  o  m
    return -1;
}

From source file:com.haulmont.cuba.gui.data.impl.CollectionPropertyDatasourceImpl.java

@Override
public K getIdByIndex(int index) {
    Collection<T> collection = getCollection();
    if (CollectionUtils.isNotEmpty(collection)) {
        return Iterables.get(collection, index).getId();
    }//ww w.j  av a  2 s.c o m
    return null;
}

From source file:com.jkoolcloud.tnt4j.streams.fields.ActivityInfo.java

/**
 * Builds {@link TrackingEvent} for activity data recording.
 *
 * @param tracker//from   w  w w . jav a2 s.  co m
 *            communication gateway to use to record activity
 * @param trackName
 *            name of tracking event
 * @param trackId
 *            identifier (signature) of tracking event
 * @param chTrackables
 *            collection to add built child trackables, not included into parent event and transmitted separately
 * @return tracking event instance
 */
protected TrackingEvent buildEvent(Tracker tracker, String trackName, String trackId,
        Collection<Trackable> chTrackables) {
    TrackingEvent event = tracker.newEvent(severity == null ? OpLevel.INFO : severity, trackName, (String) null,
            (String) null, (Object[]) null);
    event.setTrackingId(trackId);
    event.setParentId(parentId);
    // event.setCorrelator(CollectionUtils.isEmpty(correlator) ? Collections.singletonList(trackId) : correlator);
    if (CollectionUtils.isNotEmpty(correlator)) {
        event.setCorrelator(correlator);
    }
    if (CollectionUtils.isNotEmpty(tag)) {
        event.setTag(tag);
    }
    if (message != null) {
        if (message instanceof byte[]) {
            byte[] binData = (byte[]) message;
            event.setMessage(binData, (Object[]) null);
        } else {
            String strData = Utils.toString(message);
            event.setMessage(strData, (Object[]) null);
        }

        if (msgLength != null) {
            event.setSize(msgLength);
        }
    }
    if (StringUtils.isNotEmpty(msgMimeType)) {
        event.setMimeType(msgMimeType);
    }
    if (StringUtils.isNotEmpty(msgEncoding)) {
        event.setEncoding(msgEncoding);
    }
    if (StringUtils.isNotEmpty(msgCharSet)) {
        event.setCharset(msgCharSet);
    }

    event.getOperation().setCompCode(compCode == null ? OpCompCode.SUCCESS : compCode);
    event.getOperation().setReasonCode(reasonCode);
    event.getOperation().setType(eventType == null ? OpType.EVENT : eventType);
    event.getOperation().setException(exception);
    if (StringUtils.isNotEmpty(location)) {
        event.getOperation().setLocation(location);
    }
    event.getOperation().setResource(resourceName);
    event.getOperation().setUser(StringUtils.isEmpty(userName) ? tracker.getSource().getUser() : userName);
    event.getOperation().setTID(threadId == null ? Thread.currentThread().getId() : threadId);
    event.getOperation().setPID(processId == null ? Utils.getVMPID() : processId);
    // event.getOperation().setSeverity(severity == null ? OpLevel.INFO :
    // severity);
    if (eventStatus != null) {
        addActivityProperty(JSONFormatter.JSON_STATUS_FIELD, eventStatus);
    }
    event.start(startTime);
    event.stop(endTime, elapsedTime);

    if (activityProperties != null) {
        for (Property ap : activityProperties.values()) {
            if (isNotTransparentProperty(ap)) {
                if (ap.getValue() instanceof Snapshot) {
                    event.getOperation().addSnapshot((Snapshot) ap.getValue());
                } else {
                    event.getOperation().addProperty(ap);
                }
            }
        }
    }

    if (hasChildren()) {
        for (ActivityInfo child : children) {
            Trackable cTrackable = buildChild(tracker, child, trackId);
            boolean consumed = addTrackableChild(event, cTrackable);

            if (!consumed && chTrackables != null) {
                chTrackables.add(cTrackable);
            }
        }
    }

    return event;
}

From source file:com.jkoolcloud.tnt4j.streams.parsers.GenericActivityParser.java

/**
 * Converts RAW activity data using defined set of pre-parsers. Converted activity data then is parsed by parser
 * itself./*from  w w w .  j  a v  a 2  s . co  m*/
 * 
 * @param data
 *            RAW activity data to pre-parse
 * @return pre-parsers converted activity data package
 * @throws java.lang.Exception
 *             if RAW activity data pre-parsing fails
 */
protected Object preParseActivityData(Object data) throws Exception {
    if (CollectionUtils.isNotEmpty(preParsers)) {
        logger().log(OpLevel.DEBUG, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                "ActivityParser.data.before.pre.parsing"), getLogString(data));

        synchronized (PRE_PARSER_LOCK) {
            for (ActivityDataPreParser<?> preParser : preParsers) {
                boolean validData = preParser.isDataClassSupported(data);
                if (validData && getActivityDataType().equals(preParser.dataTypeReturned())) {
                    logger().log(OpLevel.DEBUG,
                            StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                                    "ActivityParser.pre.parsing.data"),
                            preParser.getClass().getSimpleName());
                    data = preParser.preParse(data);
                    logger().log(OpLevel.DEBUG,
                            StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                                    "ActivityParser.data.after.pre.parsing"),
                            getLogString(data));
                }
            }
        }
    }

    return data;
}

From source file:com.epam.catgenome.manager.GffManagerTest.java

public void checkGenesCorrectness(List<Gene> genes) {
    Assert.assertTrue(genes.stream().allMatch(g -> MapUtils.isNotEmpty(g.getAttributes())));
    Assert.assertTrue(//from  w w w .  j  a  va 2 s .c om
            genes.stream().allMatch(g -> !GeneUtils.isGene(g) || CollectionUtils.isNotEmpty(g.getItems())));
    Assert.assertTrue(genes.stream().allMatch(g -> !GeneUtils.isGene(g)
            || g.getItems().stream().allMatch(i -> MapUtils.isNotEmpty(i.getAttributes()))));
    Assert.assertTrue(genes.stream().allMatch(g -> !GeneUtils.isGene(g)
            || g.getItems().stream().allMatch(i -> CollectionUtils.isNotEmpty(i.getItems()))));
}

From source file:com.evolveum.midpoint.wf.impl.policy.AbstractWfTestPolicy.java

protected <F extends FocusType> void executeTest(String testName, TestDetails testDetails,
        int expectedSubTaskCount) throws Exception {

    // GIVEN/*from w  w  w.j a  va 2 s  .  c o m*/
    prepareNotifications();
    dummyAuditService.clear();

    Task modelTask = taskManager.createTaskInstance(AbstractWfTestPolicy.class.getName() + "." + testName);
    modelTask.setOwner(userAdministrator);
    OperationResult result = new OperationResult("execution");

    LensContext<F> modelContext = testDetails.createModelContext(result);
    display("Model context at test start", modelContext);

    // this has problems with deleting assignments by ID
    //assertFocusModificationSanity(modelContext);

    // WHEN

    HookOperationMode mode = clockwork.run(modelContext, modelTask, result);

    // THEN

    display("Model context after first clockwork.run", modelContext);
    assertEquals("Unexpected state of the context", ModelState.PRIMARY, modelContext.getState());
    assertEquals("Wrong mode after clockwork.run in " + modelContext.getState(), HookOperationMode.BACKGROUND,
            mode);
    modelTask.refresh(result);
    display("Model task after first clockwork.run", modelTask);

    String rootTaskOid = wfTaskUtil.getRootTaskOid(modelTask);
    assertNotNull("Root task OID is not set in model task", rootTaskOid);

    Task rootTask = taskManager.getTask(rootTaskOid, result);
    display("Root task after first clockwork.run", rootTask);
    assertTrue("Root task is not persistent", rootTask.isPersistent());

    UriStack uriStack = rootTask.getOtherHandlersUriStack();
    if (!testDetails.executeImmediately()) {
        assertEquals("Invalid handler at stack position 0", ModelOperationTaskHandler.MODEL_OPERATION_TASK_URI,
                uriStack.getUriStackEntry().get(0).getHandlerUri());
    } else {
        assertTrue("There should be no handlers for root tasks with immediate execution mode",
                uriStack == null || uriStack.getUriStackEntry().isEmpty());
    }

    ModelContext rootModelContext = testDetails.executeImmediately() ? null
            : wfTaskUtil.getModelContext(rootTask, result);
    if (!testDetails.executeImmediately()) {
        assertNotNull("Model context is not present in root task", rootModelContext);
    } else {
        assertNull("Model context is present in root task (execution mode = immediate)", rootModelContext);
    }

    List<Task> subtasks = rootTask.listSubtasks(result);
    Task task0 = findAndRemoveTask0(subtasks, testDetails);

    assertEquals("Incorrect number of subtasks", expectedSubTaskCount, subtasks.size());

    final Collection<SelectorOptions<GetOperationOptions>> options1 = resolveItemsNamed(
            new ItemPath(T_PARENT, F_OBJECT_REF), new ItemPath(T_PARENT, F_TARGET_REF), F_ASSIGNEE_REF,
            F_ORIGINAL_ASSIGNEE_REF, new ItemPath(T_PARENT, F_REQUESTER_REF));

    List<WorkItemType> workItems = modelService.searchContainers(WorkItemType.class, null, options1, modelTask,
            result);

    testDetails.afterFirstClockworkRun(rootTask, subtasks, workItems, result);

    if (testDetails.executeImmediately()) {
        if (task0 != null) {
            waitForTaskClose(task0, 20000);
        }
        testDetails.afterTask0Finishes(rootTask, result);
    }

    for (int i = 0; i < subtasks.size(); i++) {
        Task subtask = subtasks.get(i);
        PrismProperty<ObjectTreeDeltasType> deltas = subtask.getTaskPrismObject().findProperty(
                new ItemPath(F_WORKFLOW_CONTEXT, F_PROCESSOR_SPECIFIC_STATE, F_DELTAS_TO_PROCESS));
        assertNotNull("There are no modifications in subtask #" + i + ": " + subtask, deltas);
        assertEquals("Incorrect number of modifications in subtask #" + i + ": " + subtask, 1,
                deltas.getRealValues().size());
        // todo check correctness of the modification?

        // now check the workflow state
        String pid = wfTaskUtil.getProcessId(subtask);
        assertNotNull("Workflow process instance id not present in subtask " + subtask, pid);

        List<org.activiti.engine.task.Task> tasks = activitiEngine.getTaskService().createTaskQuery()
                .processInstanceId(pid).list();
        assertFalse("activiti task not found", tasks.isEmpty());

        for (org.activiti.engine.task.Task task : tasks) {
            String executionId = task.getExecutionId();
            display("Execution id = " + executionId);
            Boolean approve = testDetails.decideOnApproval(executionId, task);
            if (approve != null) {
                workflowManager.completeWorkItem(task.getId(), approve, null, null, null, result);
                login(userAdministrator);
                break;
            }
        }
    }

    // alternative way of approvals executions
    if (CollectionUtils.isNotEmpty(testDetails.getApprovalSequence())) {
        List<ApprovalInstruction> instructions = new ArrayList<>(testDetails.getApprovalSequence());
        while (!instructions.isEmpty()) {
            List<WorkItemType> currentWorkItems = modelService.searchContainers(WorkItemType.class, null,
                    options1, modelTask, result);
            boolean matched = false;

            Collection<ApprovalInstruction> instructionsToConsider = testDetails.strictlySequentialApprovals()
                    ? singleton(instructions.get(0))
                    : instructions;

            main: for (ApprovalInstruction approvalInstruction : instructionsToConsider) {
                for (WorkItemType workItem : currentWorkItems) {
                    if (approvalInstruction.matches(workItem)) {
                        if (approvalInstruction.beforeApproval != null) {
                            approvalInstruction.beforeApproval.run();
                        }
                        login(getUserFromRepo(approvalInstruction.approverOid));
                        System.out.println("Completing work item " + workItem.getExternalId() + " using "
                                + approvalInstruction);
                        workflowManager.completeWorkItem(workItem.getExternalId(), approvalInstruction.approval,
                                approvalInstruction.comment, null, null, result);
                        if (approvalInstruction.afterApproval != null) {
                            approvalInstruction.afterApproval.run();
                        }
                        login(userAdministrator);
                        matched = true;
                        instructions.remove(approvalInstruction);
                        break main;
                    }
                }
            }
            if (!matched) {
                fail("None of approval instructions " + instructionsToConsider
                        + " matched any of current work items: " + currentWorkItems);
            }
        }
    }

    waitForTaskClose(rootTask, 60000);

    subtasks = rootTask.listSubtasks(result);
    findAndRemoveTask0(subtasks, testDetails);
    testDetails.afterRootTaskFinishes(rootTask, subtasks, result);

    notificationManager.setDisabled(true);

    // Check audit
    display("Audit", dummyAuditService);
    display("Output context", modelContext);
}