Example usage for org.apache.commons.collections.comparators ComparatorChain addComparator

List of usage examples for org.apache.commons.collections.comparators ComparatorChain addComparator

Introduction

In this page you can find the example usage for org.apache.commons.collections.comparators ComparatorChain addComparator.

Prototype

public void addComparator(Comparator comparator, boolean reverse) 

Source Link

Document

Add a Comparator to the end of the chain using the given sort order

Usage

From source file:net.sourceforge.fenixedu.presentationTier.TagLib.sop.examsMapNew.ExamsMapRenderer.java

private void writeLineForExecutionCourseAndExamOfSeason(StringBuilder strBuffer,
        InfoExecutionCourse infoExecutionCourse, int season) {
    for (int j = 0; j < infoExecutionCourse.getAssociatedInfoExams().size(); j++) {
        InfoExam infoExam = infoExecutionCourse.getAssociatedInfoExams().get(j);
        if (infoExam.getSeason().getSeason().intValue() == season) {
            strBuffer.append("<td>" + season + "&ordf; </td>");
            strBuffer.append("<td>" + infoExam.getDate() + "</td>");
            strBuffer.append("<td>" + infoExam.getBeginningHour() + "</td>");
            strBuffer.append("<td>" + infoExam.getEndHour() + "</td>");
            strBuffer.append("<td>");
            ComparatorChain comparatorChain = new ComparatorChain();
            comparatorChain.addComparator(new BeanComparator("infoRoom.capacidadeExame"), true);
            comparatorChain.addComparator(new BeanComparator("infoRoom.nome"));
            Collections.sort(infoExam.getWrittenEvaluationSpaceOccupations(), comparatorChain);
            for (int k = 0; k < infoExam.getWrittenEvaluationSpaceOccupations().size(); k++) {
                if (k > 0) {
                    strBuffer.append(" ");
                }/* www.  j a va  2 s. c o  m*/

                InfoRoomOccupation infoRoomOccupation = infoExam.getWrittenEvaluationSpaceOccupations().get(k);
                strBuffer.append(infoRoomOccupation.getInfoRoom().getNome());
            }
            strBuffer.append("</td>");

        }
    }
}

From source file:mondrian.olap.fun.FunUtil.java

/**
 * Helper function to sort a list of tuples according to a list
 * of expressions and a list of sorting flags.
 *
 * <p>NOTE: This function does not preserve the contents of the validator.
 */// w  w w  . ja  va  2 s.c om
static TupleList sortTuples(Evaluator evaluator, TupleIterable tupleIter, TupleList tupleList,
        List<SortKeySpec> keySpecList, int arity) {
    if (tupleList == null) {
        tupleList = TupleCollections.createList(arity);
        TupleCursor cursor = tupleIter.tupleCursor();
        while (cursor.forward()) {
            tupleList.addCurrent(cursor);
        }
    }
    if (tupleList.size() <= 1) {
        return tupleList;
    }

    ComparatorChain chain = new ComparatorChain();
    for (SortKeySpec key : keySpecList) {
        boolean brk = key.direction.brk;
        boolean orderByKey = key.key.isWrapperFor(MemberOrderKeyFunDef.CalcImpl.class);
        if (brk) {
            TupleExpMemoComparator comp = new BreakTupleComparator(evaluator, key.key, arity);
            comp.preloadValues(tupleList);
            chain.addComparator(comp, key.direction.descending);
        } else if (orderByKey) {
            TupleExpMemoComparator comp = new HierarchicalTupleKeyComparator(evaluator, key.key, arity);
            comp.preloadValues(tupleList);
            chain.addComparator(comp, key.direction.descending);
        } else {
            TupleExpComparator comp = new HierarchicalTupleComparator(evaluator, key.key, arity,
                    key.direction.descending);
            chain.addComparator(comp, false);
        }
    }

    Collections.sort(tupleList, chain);

    if (LOGGER.isDebugEnabled()) {
        StringBuilder sb = new StringBuilder("FunUtil.sortTuples returned:");
        for (List<Member> tuple : tupleList) {
            sb.append("\n");
            sb.append(tuple.toString());
        }
        LOGGER.debug(sb.toString());
    }

    return tupleList;
}

From source file:mondrian.olap.fun.FunUtil.java

/**
 * Sorts a list of members according to a list of SortKeySpecs.
 * An in-place, Stable sort./*from w ww  .j  av a 2  s .  co  m*/
 * Helper function for MDX OrderSet function.
 *
 * <p>NOTE: Does not preserve the contents of the validator.
 */
static List<Member> sortMembers(Evaluator evaluator, Iterable<Member> memberIter, List<Member> memberList,
        List<SortKeySpec> keySpecList) {
    if ((memberList != null) && (memberList.size() <= 1)) {
        return memberList;
    }
    if (memberList == null) {
        memberList = new ArrayList<Member>();
        for (Member member : memberIter) {
            memberList.add(member);
        }
        if (memberList.size() <= 1) {
            return memberList;
        }
    }

    ComparatorChain chain = new ComparatorChain();
    for (SortKeySpec key : keySpecList) {
        boolean brk = key.direction.brk;
        MemberComparator comp;
        if (brk) {
            comp = new BreakMemberComparator(evaluator, key.key, key.direction.descending);
        } else {
            comp = new HierarchicalMemberComparator(evaluator, key.key, key.direction.descending);
        }
        comp.preloadValues(memberList);
        chain.addComparator(comp.wrap(), false);
    }

    Collections.sort(memberList, chain);
    return memberList;
}

From source file:org.apache.ode.bpel.engine.ProcessAndInstanceManagementImpl.java

/**
 * Query processes based on a {@link ProcessFilter} criteria. This is
 * implemented in memory rather than via database calls since the processes
 * are managed by the {@link ProcessStore} object and we don't want to make
 * this needlessly complicated./*  w w  w  .  j av  a 2s  .  co  m*/
 *
 * @param filter
 * @return
 */
@SuppressWarnings("unchecked")
Collection<ProcessConf> processQuery(ProcessFilter filter) {

    List<QName> pids = _store.getProcesses();

    // Name filter can be implemented using only the PIDs.
    if (filter != null && filter.getNameFilter() != null) {
        final Pattern pattern = Pattern.compile(filter.getNameFilter().replace("*", ".*") + "(-\\d*)?");
        CollectionsX.remove_if(pids, new MemberOfFunction<QName>() {
            @Override
            public boolean isMember(QName o) {
                return !pattern.matcher(o.getLocalPart()).matches();
            }
        });
    }

    if (filter != null && filter.getNamespaceFilter() != null) {
        final Pattern pattern = Pattern.compile(filter.getNamespaceFilter().replace("*", ".*"));
        CollectionsX.remove_if(pids, new MemberOfFunction<QName>() {
            @Override
            public boolean isMember(QName o) {
                String ns = o.getNamespaceURI() == null ? "" : o.getNamespaceURI();
                return !pattern.matcher(ns).matches();
            }

        });
    }

    // Now we need the process conf objects, we need to be
    // careful since someone could have deleted them by now
    List<ProcessConf> confs = new LinkedList<ProcessConf>();
    for (QName pid : pids) {
        ProcessConf pconf = _store.getProcessConfiguration(pid);
        confs.add(pconf);
    }

    if (filter != null) {
        // TODO Implement process status filtering when status will exist
        // Specific filter for deployment date.
        if (filter.getDeployedDateFilter() != null) {
            for (final String ddf : filter.getDeployedDateFilter()) {
                final Date dd;
                try {
                    dd = ISO8601DateParser.parse(Filter.getDateWithoutOp(ddf));
                } catch (ParseException e) {
                    // Should never happen.
                    __log.error("Exception while parsing date", e);
                    throw new RuntimeException(e.toString());
                }

                CollectionsX.remove_if(confs, new MemberOfFunction<ProcessConf>() {
                    @Override
                    public boolean isMember(ProcessConf o) {

                        if (ddf.startsWith("="))
                            return !o.getDeployDate().equals(dd);

                        if (ddf.startsWith("<="))
                            return o.getDeployDate().getTime() > dd.getTime();

                        if (ddf.startsWith(">="))
                            return o.getDeployDate().getTime() < dd.getTime();

                        if (ddf.startsWith("<"))
                            return o.getDeployDate().getTime() >= dd.getTime();

                        if (ddf.startsWith(">"))
                            return o.getDeployDate().getTime() <= dd.getTime();

                        return false;
                    }

                });

            }
        }

        // Ordering
        if (filter.getOrders() != null) {
            ComparatorChain cchain = new ComparatorChain();
            for (String key : filter.getOrders()) {
                boolean ascending = true;
                String orderKey = key;
                if (key.startsWith("+") || key.startsWith("-")) {
                    orderKey = key.substring(1, key.length());
                    if (key.startsWith("-"))
                        ascending = false;
                }

                Comparator c;
                if ("name".equals(orderKey))
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return o1.getProcessId().getLocalPart().compareTo(o2.getProcessId().getLocalPart());
                        }
                    };
                else if ("namespace".equals(orderKey))
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            String ns1 = o1.getProcessId().getNamespaceURI() == null ? ""
                                    : o1.getProcessId().getNamespaceURI();
                            String ns2 = o2.getProcessId().getNamespaceURI() == null ? ""
                                    : o2.getProcessId().getNamespaceURI();
                            return ns1.compareTo(ns2);
                        }
                    };
                else if ("version".equals(orderKey))
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            // TODO: implement version comparisons.
                            return 0;
                        }
                    };
                else if ("deployed".equals(orderKey))
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return o1.getDeployDate().compareTo(o2.getDeployDate());
                        }

                    };

                else {
                    // unrecognized
                    __log.debug("unrecognized order key" + orderKey);
                    continue;
                }

                cchain.addComparator(c, !ascending);
            }

            Collections.sort(confs, cchain);
        }

    }

    return confs;
}

From source file:org.usergrid.persistence.cassandra.QueryProcessor.java

/**
 * Perform an in memory sort of the entities
 * /*from www. j  av  a  2s. c o  m*/
 * @param entities
 * @return
 */
@SuppressWarnings("unchecked")
public List<Entity> sort(List<Entity> entities) {

    if ((entities != null) && (sorts.size() > 0)) {
        // Performing in memory sort
        logger.info("Performing in-memory sort of " + entities.size() + " entities");
        ComparatorChain chain = new ComparatorChain();
        for (SortPredicate sort : sorts) {
            chain.addComparator(new EntityPropertyComparator(sort.getPropertyName()),
                    sort.getDirection() == SortDirection.DESCENDING);
        }
        Collections.sort(entities, chain);
    }
    return entities;
}

From source file:org.vaadin.addons.javaee.container.service.ServiceContainer.java

@SuppressWarnings("unchecked")
private void sort(List<ENTITY> unsortedList) {
    if (sortDefinitions == null || sortDefinitions.isEmpty()) {
        return;//  ww w.  j  a v  a2 s.c om
    }
    ComparatorChain chain = new ComparatorChain();
    for (SortDefinition sortDefinition : sortDefinitions) {
        BeanComparator comparator = new BeanComparator(sortDefinition.getKey());
        chain.addComparator(comparator, !sortDefinition.isAscending());
    }
    try {
        Collections.sort(unsortedList, chain);
    } catch (Exception e) {
        log.error("Could not sort by " + sortDefinitions, e);
    }
}

From source file:org.wso2.carbon.bpel.core.ode.integration.mgt.services.ProcessManagementServiceSkeleton.java

/**
 * Query processes based on a {@link org.apache.ode.bpel.common.ProcessFilter} criteria. This is
 * implemented in memory rather than via database calls since the processes
 * are managed by the {@link org.apache.ode.bpel.iapi.ProcessStore} object and we don't want to make
 * this needlessly complicated./*w w w .jav a 2s .com*/
 *
 * @param filter              process filter
 * @param tenantsProcessStore Current Tenant's process store
 * @return ProcessConf collection
 * @throws ProcessManagementException if an error occurred while processing query
 */
private Collection<ProcessConf> processQuery(ProcessFilter filter, TenantProcessStoreImpl tenantsProcessStore)
        throws ProcessManagementException {

    Map<QName, ProcessConfigurationImpl> processes = tenantsProcessStore.getProcessConfigMap();
    if (log.isDebugEnabled()) {
        for (Map.Entry<QName, ProcessConfigurationImpl> process : processes.entrySet()) {
            log.debug("Process " + process.getKey() + " in state " + process.getValue());
        }
    }

    Set<QName> pids = processes.keySet();

    // Name filter can be implemented using only the PIDs.
    if (filter != null && filter.getNameFilter() != null) {
        // adding escape sequences to [\^$.|?*+(){} characters
        String nameFilter = filter.getNameFilter().replace("\\", "\\\\").replace("]", "\\]").replace("[", "\\[")
                .replace("^", "\\^").replace("$", "\\$").replace("|", "\\|").replace("?", "\\?")
                .replace(".", "\\.").replace("+", "\\+").replace("(", "\\(").replace(")", "\\)")
                .replace("{", "\\{").replace("}", "\\}").replace("*", ".*");
        final Pattern pattern = Pattern.compile(nameFilter + "(-\\d*)?");
        CollectionsX.remove_if(pids, new MemberOfFunction<QName>() {
            @Override
            public boolean isMember(QName o) {
                return !pattern.matcher(o.getLocalPart()).matches();
            }
        });
    }

    if (filter != null && filter.getNamespaceFilter() != null) {
        // adding escape sequences to [\^$.|?*+(){} characters
        String namespaceFilter = filter.getNamespaceFilter().replace("\\", "\\\\").replace("]", "\\]")
                .replace("[", "\\[").replace("^", "\\^").replace("$", "\\$").replace("|", "\\|")
                .replace("?", "\\?").replace(".", "\\.").replace("+", "\\+").replace("(", "\\(")
                .replace(")", "\\)").replace("{", "\\{").replace("}", "\\}").replace("*", ".*");
        final Pattern pattern = Pattern.compile(namespaceFilter);
        CollectionsX.remove_if(pids, new MemberOfFunction<QName>() {
            @Override
            public boolean isMember(QName o) {
                String ns = o.getNamespaceURI() == null ? "" : o.getNamespaceURI();
                return !pattern.matcher(ns).matches();
            }

        });
    }

    // Now we need the process conf objects, we need to be
    // careful since someone could have deleted them by now
    List<ProcessConf> confs = new LinkedList<ProcessConf>();
    for (QName pid : pids) {
        ProcessConf pConf = tenantsProcessStore.getProcessConfiguration(pid);
        if (pConf != null) {
            confs.add(pConf);
        }
    }

    if (filter != null) {
        // TODO Implement process status filtering when status will exist
        // Specific filter for deployment date.
        if (filter.getDeployedDateFilter() != null) {
            for (final String ddf : filter.getDeployedDateFilter()) {
                final Date dd;
                try {
                    dd = ISO8601DateParser.parse(Filter.getDateWithoutOp(ddf));
                } catch (ParseException e) {
                    // Should never happen.
                    String errMsg = "Exception while parsing date";
                    log.error(errMsg, e);
                    throw new ProcessManagementException(errMsg, e);
                }

                CollectionsX.remove_if(confs, new MemberOfFunction<ProcessConf>() {
                    @Override
                    public boolean isMember(ProcessConf o) {
                        if (ddf.startsWith("=")) {
                            return !o.getDeployDate().equals(dd);
                        }
                        if (ddf.startsWith("<=")) {
                            return o.getDeployDate().getTime() > dd.getTime();
                        }
                        if (ddf.startsWith(">=")) {
                            return o.getDeployDate().getTime() < dd.getTime();
                        }
                        if (ddf.startsWith("<")) {
                            return o.getDeployDate().getTime() >= dd.getTime();
                        }
                        return ddf.startsWith(">") && (o.getDeployDate().getTime() <= dd.getTime());
                    }
                });
            }
        }

        // Ordering
        if (filter.getOrders() != null) {
            ComparatorChain cChain = new ComparatorChain();
            for (String key : filter.getOrders()) {
                boolean ascending = true;
                String orderKey = key;
                if (key.startsWith("+") || key.startsWith("-")) {
                    orderKey = key.substring(1, key.length());
                    if (key.startsWith("-")) {
                        ascending = false;
                    }
                }

                Comparator c;
                if ("name".equals(orderKey)) {
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return o1.getProcessId().getLocalPart().compareTo(o2.getProcessId().getLocalPart());
                        }
                    };
                } else if ("namespace".equals(orderKey)) {
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            String ns1 = o1.getProcessId().getNamespaceURI() == null ? ""
                                    : o1.getProcessId().getNamespaceURI();
                            String ns2 = o2.getProcessId().getNamespaceURI() == null ? ""
                                    : o2.getProcessId().getNamespaceURI();
                            return ns1.compareTo(ns2);
                        }
                    };
                } else if ("version".equals(orderKey)) {
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return (int) (o1.getVersion() - o2.getVersion());
                        }
                    };
                } else if ("deployed".equals(orderKey)) {
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return o1.getDeployDate().compareTo(o2.getDeployDate());
                        }
                    };
                } else if ("status".equals(orderKey)) {
                    c = new Comparator<ProcessConf>() {
                        public int compare(ProcessConf o1, ProcessConf o2) {
                            return o1.getState().compareTo(o2.getState());
                        }
                    };
                } else {
                    // unrecognized
                    if (log.isDebugEnabled()) {
                        log.debug("unrecognized order key" + orderKey);
                    }
                    continue;
                }

                cChain.addComparator(c, !ascending);
            }

            Collections.sort(confs, cChain);
        }
    }

    return confs;
}