src/dochelper/MatchOrderProcessor.java

Go to the documentation of this file.

package dochelper;

import java.util.HashMap;

import dochelper.exceptions.IllegalParamterTypeException;
import dochelper.exceptions.InitializationException;
import dochelper.exceptions.InvalidValueException;
import dochelper.exceptions.MissingArgumentException;
import dochelper.exceptions.ResourceUnavailableException;
import java.util.Collections;
import java.util.Comparator;

public class MatchOrderProcessor implements Processor {

    protected static final String DIRECTION = "direction";
   
        //The parameters that describe this AlphabeticalProcessor
    protected HashMap<String, Object> params = new HashMap<String, Object>();
    
    public ResultNode operate(ResultNode doc) {

        //recurse tree in look for leaf-1 level.
        //sort children for all nodes in this level
        orderTree(doc);
        return doc;
    }


    private void orderTree(ResultNode doc) {

        if (doc.isLeaf()) return;

        //recurse until we find parent of leafs
        for(ResultNode child : doc.getChildren()) {
            orderTree(child);
        }

        Collections.sort(doc.getChildren(), new ResultNodeComparator());
    }

    public class ResultNodeComparator implements Comparator {

        public int compare(Object o1, Object o2) {

            //let class cast exception occur if objs passed are not ResultNode
            //instead of using instanceof
            ResultNode r1 = (ResultNode)o1;
            ResultNode r2 = (ResultNode)o2;

            //one null is less than the other
            if(r1.getValue()==null ^ r2.getValue() == null) {
                return (r1.getValue()==null)?-1:1;
            }
            //two nulls are equal
            else if (r1.getValue()==null && r2.getValue() == null) {
                return 0;
            }

            int base = r1.getValue().compareTo(r2.getValue());
            int direction = ((String)(params.get(DIRECTION))).equalsIgnoreCase("desc")?-1:1;

            return base*direction;
        }

    }

        public void checkParams() throws InvalidValueException, MissingArgumentException, ResourceUnavailableException {
        }

        public void init() throws InitializationException, ResourceUnavailableException {
                // Direction of the sorting process is set to asc as default
        if (!params.containsKey(DIRECTION)) {
                params.put(DIRECTION, "asc");
        }
        }

        public void setParam(String paramName, Object value)
                        throws IllegalParamterTypeException {
                params.put(paramName, value);
        }
}

---