Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.feature.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.fmap.dal.exception.DataEvaluatorRuntimeException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureQueryOrder;

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureExpressionEvaluator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.LoggerFactory;

public class DefaultFeatureQueryOrder implements FeatureQueryOrder {

    public static class FeatureQueryOrderMemberImpl implements FeatureQueryOrderMember {

        String attributeName = null;

        Evaluator evaluator = null;

//        Expression expression = null;

        boolean ascending;

        private final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(FeatureQueryOrderMember.class);

        public FeatureQueryOrderMemberImpl() {

        }

        FeatureQueryOrderMemberImpl(String attributeName, boolean ascending) {

            this.attributeName = attributeName;

            this.ascending = ascending;

        }

        FeatureQueryOrderMemberImpl(Evaluator evaluator, boolean ascending) {

            this.evaluator = evaluator;

            LOGGER.warn("Creating evaluator that will not be able to persist");

            this.ascending = ascending;

        }

        @Override

        public String toString() {

            if (this.evaluator != null) {

                return this.evaluator.getSQL() + " " + (this.ascending ? "ASC" : "DESC");

            }

            return (this.ascending ? "+" : "-") + this.attributeName;

        }

        public boolean hasEvaluator() {

            return this.evaluator != null;

        }

        public Evaluator getEvaluator() {

            return this.evaluator;

        }

        public boolean getAscending() {

            return this.ascending;

        }

        public String getAttributeName() {

            return this.attributeName;

        }

        @Override

        public void loadFromState(PersistentState state)

                throws PersistenceException {

            this.attributeName = state.getString("attributeName");

            this.ascending = state.getBoolean("ascending");

            this.evaluator = (Evaluator) state.get("evaluator");

        }

        @Override

        public void saveToState(PersistentState state)

                throws PersistenceException {

            state.set("attributeName", this.attributeName);

            state.set("ascending", this.ascending);

            if(evaluator instanceof ExpressionEvaluator){

                state.set("evaluator", evaluator);

            } else {

                state.setNull("evaluator");

            }

        }

        @Override

        public FeatureQueryOrderMember clone() throws CloneNotSupportedException {

            // Nothing more to clone

            return (FeatureQueryOrderMember) super.clone();

        }

        public void setAscending(boolean ascending) {

            this.ascending = ascending;

        }

    }

    private List<FeatureQueryOrderMember> members = new ArrayList();

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(DefaultFeatureQueryOrder.class);

    public DefaultFeatureQueryOrder() {

    }

    public void copyFrom(FeatureQueryOrder other) {

        List<FeatureQueryOrderMember> theMembers = new ArrayList<>();

        for (FeatureQueryOrderMember member : other) {

            FeatureQueryOrderMember m;

            try {

                m = member.clone();

            } catch (CloneNotSupportedException ex) {

                throw new RuntimeException("Can't copy member (" + member.toString() + ").", ex);

            }

            theMembers.add(m);

        }

        this.members = theMembers;

    }

    @Override

    public String toString() {

        StringBuilder builder = new StringBuilder();

        boolean needComma = false;

        for (FeatureQueryOrderMember member : members) {

            if (member != null && !StringUtils.isBlank(member.getAttributeName())) {

                if (needComma) {

                    builder.append(",");

                }

                builder.append(member.toString());

                needComma = true;

            }

        }

        String s = builder.toString();

        if (StringUtils.isBlank(s)) {

            return null;

        }

        return s;

    }

    public Object add(String order) {

        if (StringUtils.isEmpty(order)) {

            return null;

        }

        Object r = null;

        String[] attributes = StringUtils.split(order, ',');

        for (String attribute : attributes) {

            boolean ascending = true;

            if (attribute.startsWith("+")) {

                ascending = true;

                attribute = attribute.substring(1);

            } else if (attribute.startsWith("-")) {

                ascending = false;

                attribute = attribute.substring(1);

            }

            attribute = attribute.trim();

            r = this.add(attribute, ascending);

        }

        return r;

    }

    public Object add(String attributeName, boolean ascending) {

        FeatureQueryOrderMember member = new FeatureQueryOrderMemberImpl(

                attributeName, ascending);

        if (members.add(member)) {

            return member;

        }

        return null;

    }

    public Object add(Expression expr, boolean ascending) {

        Evaluator evaluator = new DefaultFeatureExpressionEvaluator(expr);

        FeatureQueryOrderMember member = new FeatureQueryOrderMemberImpl(

                evaluator,

                ascending);

        if (members.add(member)) {

            return member;

        }

        return null;

    }

    public Iterable<FeatureQueryOrderMember> members() {

        //    Me hubiese gustado que FeatureQueryOrder fuese Iterable, pero no se deja por 

        //    que FeatureQueryOrderMember es una clase interna y no esta definida en el 

        //    momento de poner el :

        //            implements Iterable<FeatureQueryOrderMember>

        //    Y si saco a una clase independiente FeatureQueryOrderMember se pierde 

        //    compatibilidad binaria con quien la esta usando.

        //    Para rodearlo, he creado el metodo members.

        return new Iterable<FeatureQueryOrderMember>() {

            @Override

            public Iterator<FeatureQueryOrderMember> iterator() {

                return DefaultFeatureQueryOrder.this.iterator();

            }

        };

    }

    public Iterator<FeatureQueryOrderMember> iterator() {

        if (members == null) {

            return new Iterator<FeatureQueryOrderMember>() {

                @Override

                public boolean hasNext() {

                    return false;

                }

                @Override

                public FeatureQueryOrderMember next() {

                    throw new NoSuchElementException();

                }

                @Override

                public void remove() {

                    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

                }

            };

        }

        return members.iterator();

    }

    public boolean remove(FeatureQueryOrderMember member) {

        return members.remove(member);

    }

    public void remove(int index) {

        members.remove(index);

    }

    public void clear() {

        members.clear();

    }

    public int size() {

        return this.members.size();

    }

    public int getIndex(String attributeName) {

        int n = 0;

        for (FeatureQueryOrderMember member : members) {

            if (member != null && StringUtils.equalsIgnoreCase(attributeName, member.getAttributeName())) {

                return n;

            }

            n++;

        }

        return -1;

    }

    public void movePrevious(String name) {

        int n = this.getIndex(name);

        if (n < 1) {

            return;

        }

        Collections.swap(members, n, n - 1);

    }

    public void moveNext(String name) {

        int n = this.getIndex(name);

        if (n >= this.members.size() - 1) {

            return;

        }

        Collections.swap(members, n, n + 1);

    }

    public boolean isEmpty() {

        return this.members == null || this.members.isEmpty();

    }

    public FeatureQueryOrderMember get(String attributeName) {

        for (FeatureQueryOrderMember member : members) {

            if (member != null && StringUtils.equalsIgnoreCase(attributeName, member.getAttributeName())) {

                return member;

            }

        }

        return null;

    }

    public boolean contains(String attributeName) {

        for (FeatureQueryOrderMember member : members) {

            if (member != null && StringUtils.equalsIgnoreCase(attributeName, member.getAttributeName())) {

                return true;

            }

        }

        return false;

    }

    public Comparator<Feature> getFeatureComparator() {

        return new DefaultFeatureComparator(this);

    }

    @Override

    public DefaultFeatureQueryOrder clone() throws CloneNotSupportedException {

        DefaultFeatureQueryOrder clone = (DefaultFeatureQueryOrder) super.clone();

        if (members != null) {

            clone.members = new ArrayList(members.size());

            for (int i = 0; i < members.size(); i++) {

                clone.members.add((members.get(i)).clone());

            }

        }

        return clone;

    }

    public DefaultFeatureQueryOrder getCopy() {

        DefaultFeatureQueryOrder aCopy = new DefaultFeatureQueryOrder();

        Iterator iter = this.members.iterator();

        FeatureQueryOrderMember member;

        while (iter.hasNext()) {

            member = (FeatureQueryOrderMember) iter.next();

            if (member.hasEvaluator()) {

//                aCopy.add(member.getEvaluator(), member.getAscending());

                LOGGER.warn("Evaluator is not being added to the filter in a class copy");

            } else {

                aCopy.add(member.getAttributeName(), member.getAscending());

            }

        }

        return aCopy;

    }

    /**

     * Register the class on PersistenceManager

     *

     */

    public static void registerPersistent() {

        DynStruct definitionMember

                = ToolsLocator.getPersistenceManager()

                        .addDefinition(FeatureQueryOrderMemberImpl.class,

                                "FeatureQueryOrderMember",

                                "FeatureQueryOrderMember Persistent definition",

                                null,

                                null);

        definitionMember.addDynFieldString("attributeName").setClassOfValue(String.class).setMandatory(false);

        definitionMember.addDynFieldObject("evaluator").setClassOfValue(ExpressionEvaluator.class).setMandatory(false);

        definitionMember.addDynFieldBoolean("ascending").setMandatory(false);

        DynStruct definition

                = ToolsLocator.getPersistenceManager()

                        .addDefinition(DefaultFeatureQueryOrder.class,

                                "FeatureQueryOrder",

                                "FeatureQueryOrder Persistent definition",

                                null,

                                null);

        definition.addDynFieldList("members").setClassOfItems(FeatureQueryOrderMemberImpl.class);

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        List<FeatureQueryOrderMember> stateMembers = (List) state.get("members");

        this.members = new ArrayList<>();

        for (FeatureQueryOrderMember stateMember : stateMembers) {

            this.members.add(stateMember);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("members", members);

    }

    private class DefaultFeatureComparator implements Comparator<Feature> {

        private final DefaultFeatureQueryOrder order;

        public DefaultFeatureComparator(DefaultFeatureQueryOrder order) {

            this.order = order;

            // TODO optimizar en un array???

        }

        private int myCompare(Object arg0, Object arg1) {

            if (arg0 == null) {

                if (arg1 == null) {

                    return 0;

                } else {

                    return 1;

                }

            } else if (arg1 == null) {

                if (arg0 == null) {

                    return 0;

                } else {

                    return 1;

                }

            }

            if (arg0 instanceof Comparable) {

                return ((Comparable) arg0).compareTo(arg1);

            } else if (arg1 instanceof Comparable) {

                return ((Comparable) arg1).compareTo(arg0) * -1;

            }

            if (arg0.equals(arg1)) {

                return 0;

            } else {

                return -1;

            }

        }

        @Override

        public int compare(Feature f0, Feature f1) {

            Iterator iter = this.order.iterator();

            int returnValue = 0;

//            Feature f0 = (Feature) arg0;

//            Feature f1 = (Feature) arg1;

            Object item;

            String attrName;

            Evaluator evaluator;

            while (returnValue == 0 && iter.hasNext()) {

                item = iter.next();

                if (item instanceof String) {

                    attrName = (String) item;

                    returnValue = this

                            .myCompare(f0.get(attrName), f1

                                    .get(attrName));

                } else {

                    evaluator = (Evaluator) item;

                    try {

                        returnValue = this.myCompare(evaluator

                                .evaluate((EvaluatorData) f0), evaluator

                                .evaluate((EvaluatorData) f1));

                    } catch (EvaluatorException e) {

                        throw new DataEvaluatorRuntimeException(e);

                    }

                }

            }

            return returnValue;

        }

    }

}