Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.searchpanel;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Iterator;

import java.util.function.Predicate;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.util.ChainedIterator;

/**

 *

 * @author jjdelcerro

 */

public class SearchUtils {

    private SearchUtils() {

    }

    private static final RecentUsedsAttributesImpl RECENTS_USEDS = new RecentUsedsAttributesImpl();

    public static final Predicate<FeatureAttributeDescriptor> BASIC_TYPES_FILTER = new Predicate<FeatureAttributeDescriptor>() {

        @Override

        public boolean test(FeatureAttributeDescriptor attrdesc) {

            DataType t = attrdesc.getDataType();

            boolean r = !(t.isContainer() || t.isDynObject() || t.isObject());

            return r;

        }

    };

    public static Predicate<FeatureAttributeDescriptor> ALL_FILTER = new Predicate<FeatureAttributeDescriptor>() {

        @Override

        public boolean test(FeatureAttributeDescriptor t) {

            return true;

        }

    };

    public static final Comparator<FeatureAttributeDescriptor> LABEL_ORDER = new Comparator<FeatureAttributeDescriptor>() {

        @Override

        public int compare(FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) {

            return StringUtils.compareIgnoreCase(o1.getLabel(), o2.getLabel());

        }

    };

    public static final Comparator<FeatureAttributeDescriptor> STR_INT_LONG_LABEL_ORDER = new Comparator<FeatureAttributeDescriptor>() {

        @Override

        public int compare(FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) {

            int t1 = o1.getType();

            int t2 = o2.getType();

            if( t1==DataTypes.STRING ) {

                if( t2==DataTypes.STRING ) {

                    return StringUtils.compareIgnoreCase(o1.getLabel(), o2.getLabel());

                }

                return -1;

            } else if( t2==DataTypes.STRING ) {

                return 1;

            }

            if( t1==DataTypes.INT || t1==DataTypes.LONG ) {

                if( t2==DataTypes.INT || t2==DataTypes.LONG ) {

                    return StringUtils.compareIgnoreCase(o1.getLabel(), o2.getLabel());

                }

                return -1;

            } else if( t2==DataTypes.INT || t2==DataTypes.LONG ) {

                return 1;

            }

            return StringUtils.compareIgnoreCase(o1.getLabel(), o2.getLabel());

        }

    };

    public static List<FeatureAttributeDescriptor> getOrderedAttributes(

            FeatureStore store,

            Predicate<FeatureAttributeDescriptor> filter,

            Comparator<FeatureAttributeDescriptor> comparator,

            int max

    ) {

        try {

            return getOrderedAttributes(store.getDefaultFeatureType(), filter, comparator, max);

        } catch (DataException ex) {

            throw new RuntimeException(ex);

        }

    }

    public static List<FeatureAttributeDescriptor> getOrderedAttributes(

            FeatureType featureType,

            Predicate<FeatureAttributeDescriptor> filter,

            Comparator<FeatureAttributeDescriptor> comparator,

            int max

    ) {

        List<FeatureAttributeDescriptor> mostUsed = new ArrayList<>();

        List<FeatureAttributeDescriptor> favorites = new ArrayList<>();

        List<FeatureAttributeDescriptor> normal = new ArrayList<>();

        for (FeatureAttributeDescriptor attribute : getRecentUseds().getAttributes(featureType)) {

            if (filter.test(attribute)) {

                mostUsed.add(attribute);

            }

        }

        for (FeatureAttributeDescriptor attribute : getFavoritesAttributes(featureType)) {

            if (contains(mostUsed, attribute.getName())) {

                continue;

            }

            if (filter.test(attribute)) {

                favorites.add(attribute);

            }

        }

        for (FeatureAttributeDescriptor attribute : featureType) {

            if (contains(mostUsed, attribute.getName())) {

                continue;

            }

            if (contains(favorites, attribute.getName())) {

                continue;

            }

            if (filter.test(attribute)) {

                normal.add(attribute);

            }

        }

        mostUsed.sort(comparator);

        favorites.sort(comparator);

        normal.sort(comparator);

        if (max < 0) {

            max = Integer.MAX_VALUE;

        }

        Iterator<FeatureAttributeDescriptor> it = new ChainedIterator<>(

                mostUsed.iterator(),

                favorites.iterator(),

                normal.iterator()

        );

        List<FeatureAttributeDescriptor> r = new ArrayList<>();

        int n = 0;

        while (n < max && it.hasNext()) {

            r.add(it.next());

            n++;

        }

        return r;

    }

    private static boolean contains(List<FeatureAttributeDescriptor> attributes, String name) {

        if (StringUtils.isBlank(name)) {

            return false;

        }

        for (FeatureAttributeDescriptor attribute : attributes) {

            if (StringUtils.equalsIgnoreCase(name, attribute.getName())) {

                return true;

            }

        }

        return false;

    }

    public static RecentUsedsAttributesImpl getRecentUseds() {

        return RECENTS_USEDS;

    }

    public static Collection<FeatureAttributeDescriptor> getFavoritesAttributes(FeatureType featureType) {

        return Collections.EMPTY_LIST;

    }

}