Application: gvSIG desktop

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

import java.util.Arrays;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.complement.AbstractComplement;

import org.gvsig.tools.complement.ComplementFactory;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.Tagged;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class RelatedFeaturesImpl

        extends AbstractComplement<Tagged>

        implements RelatedFeatures {

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

    private class DefaultContextRelatedFeatures implements ContextRelatedFeatures {

        private FeatureStore featureStore = null;

        private StoresRepository storesRepository = null;

        private int refs;

        public DefaultContextRelatedFeatures() {

            this.refs = 1;

        }

        public void addRef() {

            this.refs++;

        }

        public void release() {

            this.refs--;

        }

        @Override

        public void dispose() {

            DisposeUtils.disposeQuietly(featureStore);

            this.featureStore = null;

            this.storesRepository = null;

        }

        @Override

        public ContextRelatedFeatures setStoresRepository(StoresRepository repository) {

            this.storesRepository = repository;

            return this;

        }

        @Override

        public StoresRepository getStoresRepository() {

            if (this.storesRepository == null) {

                FeatureStore store = null;

                if (getObject() instanceof FeatureAttributeDescriptor) {

                    store = ((FeatureAttributeDescriptor) getObject()).getStore();

                } else if (getObject() instanceof FeatureType) {

                    store = ((FeatureType) getObject()).getStore();

                }

                if (store == null) {

                    this.storesRepository = DALLocator.getDataManager().getStoresRepository();

                } else {

                    this.storesRepository = store.getStoresRepository();

                }

            }

            return this.storesRepository;

        }

        @Override

        public FeatureStore getFeatureStore() {

            if (this.featureStore == null) {

                if ( getObject() instanceof FeatureAttributeDescriptor) {

                    FeatureStore store = ((FeatureAttributeDescriptor) getObject()).getStore();

                    if( store != null ) {

                        StoresRepository repository = store.getStoresRepository();

                        if( repository.containsKey(getTableName()) ) {

                            this.featureStore = (FeatureStore) repository.get(getTableName());

                            if( this.featureStore!=null) {

                                return this.featureStore;

                            }

                        }

                    }

                } 

                StoresRepository repository = this.getStoresRepository();

                this.featureStore = (FeatureStore) repository.get(getTableName());

                if (this.featureStore == null) {

                    LOGGER.warn("Can't locate store '" + getTableName() + "'.");

                    return null;

                }

            }

            return this.featureStore;

        }

        @Override

        public FeatureType getFeatureType() {

            try {

                FeatureStore store = this.getFeatureStore();

                return store.getDefaultFeatureType();

            } catch (Exception ex) {

                return null;

            }

        }

    }

    public RelatedFeaturesImpl(ComplementFactory<Tagged> factory, Tagged object) {

        super(factory, object);

    }

    @Override

    public boolean isRelatedFeatures() {

        return isRelatedFeatures(null);

    }

    @Override

    public boolean isRelatedFeatures(ContextRelatedFeatures context) {

        context = createLocalContextIfNull(context);

        try {

            String tableName = this.getTableName();

            if (StringUtils.isBlank(tableName)

                    || StringUtils.isBlank(this.getUniqueKeyName())) {

                return false;

            }

            Tagged attribute = this.getObject();

            if (!(attribute instanceof FeatureAttributeDescriptor)) {

                return true;

            }

            FeatureStore store = ((FeatureAttributeDescriptor) attribute).getStore();

            if (store == null) {

                return true;

            }

            StoresRepository repository = store.getStoresRepository();

            return repository.containsKey(tableName);

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public String getUniqueKeyName() {

        Tagged attribute = this.getObject();

        String codeName = attribute.getTags().getString(DAL_RELATED_UNIQUE_FIELD_NAME, null);

        return codeName;

    }

//    @Override

//    public String getForeingKeyName() {

//        Tagged attribute = this.getObject();

//        String codeName = attribute.getTags().getString(DAL_RELATED_FOREING_KEY_NAME, null);

//        return codeName;

//    }

    @Override

    public String getTableName() {

        Tagged attribute = this.getObject();

        String tableName = attribute.getTags().getString(DAL_RELATED_TABLE, null);

        return tableName;

    }

    @Override

    public ContextRelatedFeatures createContext() {

        return new DefaultContextRelatedFeatures();

    }

    private void disposeIfLocalContext(ContextRelatedFeatures context) {

        DefaultContextRelatedFeatures c = (DefaultContextRelatedFeatures) context;

        c.release();

        if (c.refs == 0) {

            context.dispose();

        }

    }

    private ContextRelatedFeatures createLocalContextIfNull(ContextRelatedFeatures context) {

        if (context == null) {

            return new DefaultContextRelatedFeatures();

        }

        DefaultContextRelatedFeatures c = (DefaultContextRelatedFeatures) context;

        c.addRef();

        return c;

    }

    @Override

    public FeatureStore getFeatureStore(ContextRelatedFeatures context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getFeatureStore();

        } finally {

            disposeIfLocalContext(context);

        }

    }

//    @Override

//    public Object getForeingKey(ContextRelatedFeatures context, Feature feature) {

////        context = createLocalContextIfNull(context);

//        try {

//            return feature.get(getForeingKeyName());

//        } finally {

////            disposeIfLocalContext(context);

//        }

//    }

    @Override

    public Object getUniqueKey(ContextRelatedFeatures context, Feature feature) {

//        context = createLocalContextIfNull(context);

        try {

            return feature.get(getUniqueKeyName());

        } finally {

//            disposeIfLocalContext(context);

        }

    }

//    @Override

//    public FeatureQuery getForeingKeyQuery(ContextRelatedFeatures context, Object codeValue) {

//        return this.getQuery(context, this.getForeingKeyName(), codeValue);

//    }

    @Override

    public FeatureQuery getUniqueKeyQuery(ContextRelatedFeatures context, Object codeValue) {

        return this.getQuery(context, this.getUniqueKeyName(), codeValue);

    }

    public FeatureQuery getQuery(ContextRelatedFeatures context, String fieldName, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            FeatureStore store = context.getFeatureStore();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            FeatureQuery query = store.createFeatureQuery();

            query.setFilter(builder.eq(

                    builder.variable(fieldName),

                    builder.constant(codeValue)

            ).toString()

            );

            query.retrievesAllAttributes();

            return query;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public List<String> getColumns(ContextRelatedFeatures context) {

        context = createLocalContextIfNull(context);

        try {

            Tagged attribute = this.getObject();

            List<String> columnNames;

            String columns = attribute.getTags().getString(DAL_RELATED_COLUMNS, null);

            if (StringUtils.isBlank(columns)) {

                FeatureType featureType = context.getFeatureType();

                if (featureType == null) {

                    return null;

                }

                Search search = (Search) ToolsLocator.getComplementsManager().get(

                        Search.COMPLEMENT_MANE, featureType

                );

                columnNames = search.getResultColumnNames();

            } else {

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

            }

            return columnNames;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    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 + "]");

    }

}