Example usage for org.apache.commons.collections CollectionUtils subtract

List of usage examples for org.apache.commons.collections CollectionUtils subtract

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections.*
  5. CollectionUtils
  6. subtract

Introduction

In this page you can find the example usage for org.apache.commons.collections CollectionUtils subtract.

Prototype

public static Collection subtract(final Collection a, final Collection b)

Source Link

Document

Returns a new Collection containing a - b.

Usage

From source file:biz.netcentric.cq.tools.actool.authorizableutils.impl.AuthorizableCreatorServiceImpl.java

@SuppressWarnings("unchecked")
void mergeMemberOfGroups(String principalId, AcInstallationHistoryPojo status, UserManager userManager,
        Set<String> membershipGroupsFromConfig, Set<String> membershipGroupsFromRepository)
        throws RepositoryException, AuthorizableExistsException, AuthorizableCreatorException {
    LOG.debug("mergeMemberOfGroups() for {}", principalId);

    // membership to everyone cannot be removed or added => take it out from both lists
    membershipGroupsFromConfig.remove(PRINCIPAL_EVERYONE);
    membershipGroupsFromRepository.remove(PRINCIPAL_EVERYONE);

    logAndVerboseHistoryMessage(status,/*from  w  w w  .  j  av a 2  s.c o  m*/
            "Principal " + principalId + " isMemberOf(repo)=" + membershipGroupsFromRepository);
    logAndVerboseHistoryMessage(status,
            "Principal " + principalId + " isMemberOf(conifg)=" + membershipGroupsFromConfig);

    Set<String> validatedMembershipGroupsFromConfig = validateAssignedGroups(userManager, principalId,
            membershipGroupsFromConfig);

    Collection<String> unChangedMembers = CollectionUtils.intersection(membershipGroupsFromRepository,
            validatedMembershipGroupsFromConfig);
    logAndVerboseHistoryMessage(status,
            "Principal " + principalId + " remains member of groups " + unChangedMembers);

    Collection<String> toBeAddedMembers = CollectionUtils.subtract(validatedMembershipGroupsFromConfig,
            membershipGroupsFromRepository);
    logAndVerboseHistoryMessage(status,
            "Principal " + principalId + " will be added as member of " + toBeAddedMembers);

    Collection<String> toBeRemovedMembers = CollectionUtils.subtract(membershipGroupsFromRepository,
            validatedMembershipGroupsFromConfig);
    Set<String> toBeSkippedFromRemovalMembers = new HashSet<String>();

    Pattern ignoredMembershipsPattern = status.getAcConfiguration().getGlobalConfiguration()
            .getAllowExternalGroupNamesRegEx();

    Iterator<String> toBeRemovedMembersIt = toBeRemovedMembers.iterator();
    while (toBeRemovedMembersIt.hasNext()) {
        String groupId = toBeRemovedMembersIt.next();
        if ((ignoredMembershipsPattern != null) && ignoredMembershipsPattern.matcher(groupId).find()) {
            toBeSkippedFromRemovalMembers.add(groupId);
            toBeRemovedMembersIt.remove();
        }
    }
    logAndVerboseHistoryMessage(status,
            "Principal " + principalId + " will be removed from members of " + toBeRemovedMembers);

    if (!toBeSkippedFromRemovalMembers.isEmpty()) {
        logAndVerboseHistoryMessage(status,
                "Principal " + principalId + " remains member of groups " + toBeSkippedFromRemovalMembers
                        + " (due to configured ignoredMembershipsPattern=" + ignoredMembershipsPattern + ")");

    }

    // perform changes

    Authorizable currentAuthorizable = userManager.getAuthorizable(principalId);

    for (String groupId : toBeAddedMembers) {
        LOG.debug("Membership Change: Adding {} to members of group {} in repository", principalId, groupId);
        Authorizable targetAuthorizable = userManager.getAuthorizable(groupId);
        ((Group) targetAuthorizable).addMember(currentAuthorizable);
    }

    for (String groupId : toBeRemovedMembers) {
        LOG.debug("Membership Change: Removing {} from members of group {} in repository", principalId,
                groupId);
        Authorizable targetAuthorizable = userManager.getAuthorizable(groupId);
        ((Group) targetAuthorizable).removeMember(currentAuthorizable);
    }

    if (!toBeAddedMembers.isEmpty() && !toBeAddedMembers.isEmpty()) {
        logAndVerboseHistoryMessage(status, "Membership Change: Principal " + principalId + " was added to "
                + toBeAddedMembers.size() + " and removed from " + toBeRemovedMembers.size() + " groups");
    }

}

From source file:net.sourceforge.fenixedu.domain.candidacyProcess.mobility.MobilityApplicationProcess.java

public List<ErasmusCandidacyProcessReport> getUndoneReports() {
    return new ArrayList(CollectionUtils.subtract(getErasmusCandidacyProcessReportsSet(), getDoneReports()));
}

From source file:net.sourceforge.fenixedu.domain.student.importation.DgesStudentImportationProcess.java

public static List<DgesStudentImportationProcess> readUndoneJobs(final ExecutionYear executionYear) {
    return new ArrayList(CollectionUtils.subtract(readAllJobs(executionYear), readDoneJobs(executionYear)));
}

From source file:com.github.NearestNeighbors.java

/**
 * Calculates accuracy between actual and predicted watchers.
 * /*from   ww  w  .  j av  a 2  s  .  c  o  m*/
 * @param actual
 * @param predicted
 * @return
 */
public static float accuracy(final Watcher actual, final Watcher predicted) {
    if ((actual == null) || (predicted == null)) {
        return 0.0f;
    }

    if ((actual.repositories.isEmpty()) && (predicted.repositories.isEmpty())) {
        return 1.0f;
    }

    if ((actual.repositories.isEmpty()) && (!predicted.repositories.isEmpty())) {
        return 0.0f;
    }

    if ((actual.repositories.isEmpty()) || (predicted.repositories.isEmpty())) {
        return 0.0f;
    }

    int number_correct = CollectionUtils.intersection(actual.repositories, predicted.repositories).size();
    int number_incorrect = CollectionUtils.subtract(predicted.repositories, actual.repositories).size();

    // Rate the accuracy of the predictions, with a bias towards positive results.
    return ((float) number_correct) / actual.repositories.size(); // - ((float) (number_incorrect) / predicted.repositories.size();
}

From source file:net.mojodna.searchable.AbstractSearcher.java

/**
 * Gets a list of all fields present in the index.
 * // w  w w .  j a  v  a 2  s  .com
 * @param reader IndexReader to use to obtain fields.
 * @return Array of field names.
 */
protected String[] getFieldsPresent(final IndexReader reader) {
    return SearchableUtils.toStringArray(CollectionUtils
            .subtract(reader.getFieldNames(IndexReader.FieldOption.ALL), IndexSupport.PRIVATE_FIELD_NAMES));
}

From source file:com.jaspersoft.jasperserver.api.metadata.user.service.impl.UserAuthorityServiceImpl.java

/**
 * Ensure the external user has the right roles. Roles attached to the userDetails are the definitive list
 * of externally defined roles./*from   www. j  a va2s  . c  o  m*/
 *
 * @param externalRoles
 * @param user
 */
protected void alignInternalAndExternalUser(Set externalRoles, User user) {

    final Predicate externallyDefinedRoles = new Predicate() {
        public boolean evaluate(Object input) {
            if (!(input instanceof Role)) {
                return false;
            }
            return ((Role) input).isExternallyDefined();
        }
    };

    Set currentRoles = user.getRoles();

    // we may have a new user, so always persist them
    boolean persistUserNeeded = (currentRoles.size() == 0);
    /*
           // If it is externally authenticated, no save of password
           if (!user.getPassword().equals(userDetails.getPassword())) {
              user.setPassword(userDetails.getPassword());
              persistUserNeeded = true;
           }
            
    */ Collection currentExternalRoles = CollectionUtils.select(user.getRoles(), externallyDefinedRoles);
    if (log.isDebugEnabled()) {
        log.debug("Login of external User: " + user.getUsername());
        log.debug("Roles from authentication:\n" + roleCollectionToString(externalRoles));
        log.debug("Current roles from metadata:\n" + roleCollectionToString(user.getRoles()));
        log.debug("Current external roles for user from metadata: " + user.getUsername() + "\n"
                + roleCollectionToString(currentExternalRoles));
    }

    /*
       * If we have new external roles, we want to add them
       */
    Collection newExternalRoles = CollectionUtils.subtract(externalRoles, currentExternalRoles);

    if (newExternalRoles.size() > 0) {
        currentRoles.addAll(newExternalRoles);
        if (log.isWarnEnabled()) {
            log.warn("Added following external roles to: " + user.getUsername() + "\n"
                    + roleCollectionToString(newExternalRoles));
        }
        persistUserNeeded = true;
    }

    /*
       * If external roles have been removed, we need to remove them
       */
    Collection rolesNeedingRemoval = CollectionUtils.subtract(currentExternalRoles, externalRoles);

    if (rolesNeedingRemoval.size() > 0) {
        currentRoles.removeAll(rolesNeedingRemoval);
        if (log.isWarnEnabled()) {
            log.warn("Removed following external roles from: " + user.getUsername() + "\n"
                    + roleCollectionToString(rolesNeedingRemoval));
        }
        persistUserNeeded = true;
    }

    /*
       * If we have new default internal roles, we want to add them
       */
    Collection defaultInternalRolesToAdd = CollectionUtils.subtract(getNewDefaultInternalRoles(), currentRoles);

    if (defaultInternalRolesToAdd.size() > 0) {
        if (log.isDebugEnabled()) {
            log.debug("Default internal roles: " + roleCollectionToString(getNewDefaultInternalRoles()));
        }
        currentRoles.addAll(defaultInternalRolesToAdd);
        if (log.isWarnEnabled()) {
            log.warn("Added following new default internal roles to: " + user.getUsername() + "\n"
                    + roleCollectionToString(defaultInternalRolesToAdd));
        }
        persistUserNeeded = true;
    }

    if (persistUserNeeded) {
        if (log.isWarnEnabled()) {
            log.warn("Updated user: " + user.getUsername() + ". Roles are now:\n"
                    + roleCollectionToString(currentRoles));
        }
        user.setRoles(currentRoles);
        // persist user and roles
        doPutUser(new ExecutionContextImpl(), user);
        if (log.isWarnEnabled()) {
            log.warn("Updated user: " + user.getUsername() + ". Roles are now:\n"
                    + roleCollectionToString(currentRoles));
        }
    }

}

From source file:com.amalto.workbench.utils.LocalTreeObjectRepository.java

public void mergeImportCategory(TreeObject[] xobjectsToImport, TreeParent serverRoot) {
    if (xobjectsToImport.length == 0 || originalImportXobjects == null || originalImportXobjects.length == 0) {
        return;//from  ww  w .  j a va2  s. c o  m
    }

    Collection dels = CollectionUtils.subtract(Arrays.asList(originalImportXobjects),
            Arrays.asList(xobjectsToImport));
    ArrayList<TreeObject> delList = new ArrayList<TreeObject>(dels);
    ArrayList<String> xpaths = new ArrayList<String>();

    for (TreeObject del : delList) {
        String xpath = this.getXPathForTreeObject(del);
        xpath.replaceFirst("/" + del.getServerRoot().getUser().getUsername(), //$NON-NLS-1$
                "/" + serverRoot.getUser().getUsername());//$NON-NLS-1$
        xpaths.add(xpath);
    }

    mergeImportCategory(importCategories, serverRoot, xpaths);
}

From source file:edu.jhuapl.openessence.datasource.jdbc.entry.JdbcOeDataEntrySource.java

/**
 * Takes collection of db-key/value pairings from the original and replacement records. Returns a map of
 * sqlOperation/list of db-key/value pairings. The 3 sqlOperations are "INSERT" "UPDATE" and "DELETE." Basic logic is
 * this:/*from   www .j av  a2  s  .c  o m*/
 *
 * UPDATE - pk/val exists in original AND replacement record INSERT - pk/val exists in replacement record but NOT in
 * original record DELETE - pk/val exists in origianal record but NOT in replacement record
 *
 * @param originalPks    original record's set of (dbkeys<->values)
 * @param replacementPks replacement record's set of (dbkeys<->values)
 * @return categorization of the original and replacement records' (dbkeys<->values) into INSERT, UPDATE, DELETE
 *         operations
 */
public Map<String, List<Map<String, Object>>> categorizePKs(Set<Map<String, Object>> originalPks,
        Set<Map<String, Object>> replacementPks) {
    Set<Map<String, Object>> ORIG = originalPks;
    Set<Map<String, Object>> REPL = replacementPks;

    List<Map<String, Object>> UPDATE = new ArrayList<Map<String, Object>>();
    List<Map<String, Object>> INSERT = new ArrayList<Map<String, Object>>();
    List<Map<String, Object>> DELETE = new ArrayList<Map<String, Object>>();

    UPDATE.addAll(CollectionUtils.intersection(ORIG, REPL));
    INSERT.addAll(CollectionUtils.subtract(REPL, ORIG));
    DELETE.addAll(CollectionUtils.subtract(ORIG, REPL));

    Map<String, List<Map<String, Object>>> categorizedPKs = new HashMap<String, List<Map<String, Object>>>();
    categorizedPKs.put("UPDATE", UPDATE);
    categorizedPKs.put("INSERT", INSERT);
    categorizedPKs.put("DELETE", DELETE);

    log.debug("pks for update: " + UPDATE);
    log.debug("pks for insertion: " + INSERT);
    log.debug("pks for deletion: " + DELETE);
    return categorizedPKs;
}

From source file:com.mirth.connect.client.ui.Frame.java

/**
 * Adds dependent/dependency dashboard statuses to the given set, based on the type of task
 * being performed./*  w ww  .j  a  va  2 s .  c om*/
 */
private boolean getStatusesWithDependencies(Set<DashboardStatus> selectedDashboardStatuses, ChannelTask task) {
    try {
        ChannelDependencyGraph channelDependencyGraph = new ChannelDependencyGraph(
                channelPanel.getCachedChannelDependencies());
        Set<String> selectedChannelIds = new HashSet<String>();
        Set<String> channelIdsToHandle = new HashSet<String>();

        Map<String, DashboardStatus> statusMap = new HashMap<String, DashboardStatus>();
        for (DashboardStatus dashboardStatus : status) {
            statusMap.put(dashboardStatus.getChannelId(), dashboardStatus);
        }

        // For each selected channel, add any dependent/dependency channels as necessary
        for (DashboardStatus dashboardStatus : selectedDashboardStatuses) {
            selectedChannelIds.add(dashboardStatus.getChannelId());
            addChannelToTaskSet(dashboardStatus.getChannelId(), channelDependencyGraph, statusMap,
                    channelIdsToHandle, task);
        }

        // If additional channels were added to the set, we need to prompt the user
        if (!CollectionUtils.subtract(channelIdsToHandle, selectedChannelIds).isEmpty()) {
            ChannelDependenciesWarningDialog dialog = new ChannelDependenciesWarningDialog(task,
                    channelPanel.getCachedChannelDependencies(), selectedChannelIds, channelIdsToHandle);
            if (dialog.getResult() == JOptionPane.OK_OPTION) {
                if (dialog.isIncludeOtherChannels()) {
                    for (String channelId : channelIdsToHandle) {
                        selectedDashboardStatuses.add(statusMap.get(channelId));
                    }
                }
            } else {
                return false;
            }
        }
    } catch (ChannelDependencyException e) {
        // Should never happen
        e.printStackTrace();
    }

    return true;
}

From source file:nl.strohalm.cyclos.services.elements.ElementServiceImpl.java

@SuppressWarnings("unchecked")
@Override//  w  w  w .ja  v a 2 s.  com
public BulkMemberActionResultVO bulkChangeMemberChannels(final FullTextMemberQuery query,
        Collection<Channel> enableChannels, Collection<Channel> disableChannels) throws ValidationException {
    validateBulkChangeChannels(query, enableChannels, disableChannels);

    // load the channels to ensure they are valid ones
    enableChannels = channelService.load(EntityHelper.toIds(enableChannels));
    disableChannels = channelService.load(EntityHelper.toIds(disableChannels));

    int changed = 0, unchanged = 0;
    // force the result type to ITERATOR to avoid load all members in memory
    query.setIterateAll();
    final List<Member> members = (List<Member>) fullTextSearch(query);
    CacheCleaner cacheCleaner = new CacheCleaner(fetchService);
    for (Member member : members) {
        member = fetchService.fetch(member, Member.Relationships.CHANNELS, Element.Relationships.GROUP);
        boolean mustChange = false;

        for (Channel channel : enableChannels) {
            if (accessService.isChannelAllowedToBeEnabledForMember(channel, member)
                    && !member.getChannels().contains(channel)) {
                mustChange = true;
                member.getChannels().add(channel);
            }
        }
        Collection<Channel> memberChannels = accessService.getChannelsEnabledForMember(member);
        Collection<Channel> memberDisabledChannels = CollectionUtils.subtract(channelService.list(),
                memberChannels);
        Collection<Channel> toDisableChannels = CollectionUtils.subtract(disableChannels,
                memberDisabledChannels);
        if (CollectionUtils.isNotEmpty(toDisableChannels)) {
            mustChange = true;
            // at this point disableChannels contains only actually enabled member channels
            for (Channel channel : toDisableChannels) {
                member.getChannels().remove(channel);
            }
        }

        if (mustChange) {
            changed++;
            elementDao.update(member);
        } else {
            unchanged++;
        }

        cacheCleaner.clearCache();
    }

    return new BulkMemberActionResultVO(changed, unchanged);
}