src/dochelper/NaturalOrderParamProcessor.java

Go to the documentation of this file.

/*
 * NaturalOrderProcessor.java
 *
 * Created on June 16, 2009, 1:44 PM
 *
 * Copyright 2009 Online Nederland Breedband B.V.
 * See the COPYRIGHT file for redistribution and use restrictions.
 * Authors: Guillermo Christen <guillermo.christen@is.online.nl>
 */
package dochelper;

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

public class NaturalOrderParamProcessor implements Processor {


    protected static final String DIRECTION = "direction";
    protected static final String SORT_PARAM = "sortparam";

    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);
        }

        //TODO: Document better
        //Sort the items using the value within their params Map that matched the passed in key
        Collections.sort(doc.getChildren(), new ParamResultNodeComparator((String)params.get(SORT_PARAM)));
        
    }

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


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

        //if no sort param has been specified throw an exception
        if(!params.containsKey(SORT_PARAM))
            throw new MissingArgumentException(SORT_PARAM);
    }


    public void init() throws InitializationException, ResourceUnavailableException {
        //nothing to initialize        
    }

    public class ParamResultNodeComparator implements Comparator {

        private String paramKey;

        public ParamResultNodeComparator(String paramKey) {
            this.paramKey = paramKey;
        }

        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;

            if(r1.getParams()==null || r2.getParams() == null)
                return 0;

            Comparable p1 = (Comparable)r1.getParams().get(paramKey);
            Comparable p2 = (Comparable)r2.getParams().get(paramKey);

            //if the items being searched don't have the search param leave as is
            if(p1==null||p2==null)
                return 0;

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

            return base*direction;
        }
    }
}

---