Application: gvSIG desktop

package org.gvsig.fmap.dal.complements.search;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.function.Predicate;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.complements.Search;

import static org.gvsig.fmap.dal.complements.Search.DAL_SEARCH_ATTRIBUTE_PRIORITY;

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

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

import org.gvsig.tools.complement.AbstractComplement;

import org.gvsig.tools.complement.ComplementFactory;

import org.gvsig.tools.util.ChainedIterator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SearchImpl

        extends AbstractComplement<FeatureType>

        implements Search {

    protected static final Logger LOGGER = LoggerFactory.getLogger(SearchImpl.class);

    public SearchImpl(ComplementFactory<FeatureType> factory, FeatureType object) {

        super(factory, object);

    }

    @Override

    public List<String> getResultColumnNames() {

        FeatureType featureType = this.getObject();

        List<String> columnNames;

        String columns = featureType.getTags().getString(DataManager.DAL_PREFERRED_COLUMNS, null);

        if( StringUtils.isBlank(columns) ) {

            List<FeatureAttributeDescriptor> attributes = featureType.getFilteredAttributes(

                    FeatureType.BASIC_TYPES_FILTER,

                    12

            );

            attributes.sort(Search.STR_INT_LONG_LABEL_ORDER);

            columnNames = new ArrayList<>();

            for (FeatureAttributeDescriptor attr : attributes) {

                columnNames.add(attr.getName());

            }

        } else {

            columnNames = Arrays.asList(split(columns, ":/;,|-"));

        }

        return columnNames;

    }

    private String[] split(String value, String separators) {

        int firstSeparatorPosition = 1000000;

        Character sep = null;

        for (char ch : separators.toCharArray()) {

            int pos = value.indexOf(ch);

            if( pos>0 && pos<firstSeparatorPosition ) {

                sep = ch;

                firstSeparatorPosition = pos;

            }

        }

        if( sep == null ) {

            return new String[] { value };

        }

        return value.split("["+sep+"]");

    }

    private static class AnOrderedAttribute implements OrderedAttribute {

        private final FeatureAttributeDescriptor descriptor;

        private final int type;

        public AnOrderedAttribute(FeatureAttributeDescriptor descriptor, int type) {

            this.descriptor = descriptor;

            this.type = type;

        }

        @Override

        public FeatureAttributeDescriptor getDescriptor() {

            return descriptor;

        }

        @Override

        public int getType() {

            return type;

        }

    }

    @Override

    public List<OrderedAttribute> getOrderedAttributes(

            Predicate<FeatureAttributeDescriptor> filter, 

            final Comparator<FeatureAttributeDescriptor> comparator,

            int max

        ) {

        return this.getOrderedAttributes(filter, comparator, max, null);

    }

    @Override

    public List<OrderedAttribute> getOrderedAttributes(

            Predicate<FeatureAttributeDescriptor> filter, 

            final Comparator<FeatureAttributeDescriptor> comparator,

            int max,

            List<FeatureAttributeDescriptor> extra

        ) {

        FeatureType tthis = this.getObject();

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

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

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

        for (FeatureAttributeDescriptor attribute : tthis.getRecentUseds()) {

            mostUsed.add(new AnOrderedAttribute(attribute, OrderedAttribute.TYPE_RECENT));

        }

        for (FeatureAttributeDescriptor attribute : this.getFavorites()) {

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

                continue;

            }

            if (filter.test(attribute)) {

                favorites.add(new AnOrderedAttribute(attribute, OrderedAttribute.TYPE_FAVORITE));

            }

        }

        for (FeatureAttributeDescriptor attribute : tthis.getAllAttributeDescriptors()) {

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

                continue;

            }

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

                continue;

            }

            if (filter.test(attribute)) {

                normal.add(new AnOrderedAttribute(attribute, OrderedAttribute.TYPE_REGURAL));

            }

        }

        if(extra != null){

            for (FeatureAttributeDescriptor attribute : extra) {

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

                    continue;

                }

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

                    continue;

                }

                if (filter.test(attribute)) {

                    normal.add(new AnOrderedAttribute(attribute, OrderedAttribute.TYPE_EXTRA));

                }

            }

        }

        Comparator<OrderedAttribute> comparatorAdapter = new Comparator<OrderedAttribute>() {

            @Override

            public int compare(OrderedAttribute o1, OrderedAttribute o2) {

                return comparator.compare(o1.getDescriptor(), o2.getDescriptor());

            }

        };

        mostUsed.sort(comparatorAdapter);

        favorites.sort(comparatorAdapter);

        normal.sort(comparatorAdapter);

        if (max < 0) {

            max = Integer.MAX_VALUE;

        }

        Iterator<OrderedAttribute> it = new ChainedIterator<>(

                mostUsed.iterator(),

                favorites.iterator(),

                normal.iterator()

        );

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

        int n = 0;

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

            r.add(it.next());

            n++;

        }

        return r;

    }

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

        if (StringUtils.isBlank(name)) {

            return false;

        }

        for (OrderedAttribute attribute : attributes) {

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

                return true;

            }

        }

        return false;

    }

    @Override

    public int getPriority(FeatureAttributeDescriptor attribute) {

        if( attribute==null || attribute.getTags()==null ) {

            return 0;

        }

        int p = attribute.getTags().getInt(DAL_SEARCH_ATTRIBUTE_PRIORITY, 0);

        return p;

    }

    @Override

    public List<FeatureAttributeDescriptor> getFavorites() {

        FeatureType featureType= this.getObject();

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

        for (FeatureAttributeDescriptor attribute : featureType) {

            if( this.getPriority(attribute)>0 ) {

                attrs.add(attribute);

            }

        }

        if( attrs.isEmpty() ) {

            return Collections.EMPTY_LIST;

        }

        attrs.sort(new Comparator<FeatureAttributeDescriptor>() {

            @Override

            public int compare(FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) {

                return Integer.compare(getPriority(o1), getPriority(o2));

            }

        });

        return attrs;

    }

}