Application: gvSIG desktop

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

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

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

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.StoresRepository;

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

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultForeingKey implements Persistent, ForeingKey, EditableForeingKey, org.gvsig.tools.lang.Cloneable {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultForeingKey.class);

    private class DefaultContextForeingKey implements ContextForeingKey {

        private FeatureStore featureStore = null;

        private StoresRepository storesRepository = null;

        private Expression labelExpression;

        private SymbolTable symbolTable;

        private FeatureSymbolTable featureSymbolTable;

        private int refs;

        public DefaultContextForeingKey() {

            this.refs = 1;

        }

        public void addRef() {

            this.refs++;

        }

        public void relese() {

            this.refs--;

        }

        @Override

        public void dispose() {

            DisposeUtils.disposeQuietly(featureStore);

            this.featureStore = null;

            this.storesRepository = null;

            this.labelExpression = null;

            this.symbolTable = null;

            this.featureSymbolTable = null;

        }

        @Override

        public StoresRepository getStoresRepository() {

            if (this.storesRepository == null) {

                FeatureStore store = descriptor.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) {

                StoresRepository repository = this.getStoresRepository();

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

                if (this.featureStore == null) {

                    LOGGER.warn("Can't locate store '" + tableName + "' to get available values of field '" + descriptor.getName() + "'.");

                    return null;

                }

            }

            return this.featureStore;

        }

        @Override

        public Expression getLabelExpression() {

            if (this.labelExpression == null) {

                if (StringUtils.isBlank(labelFormula)) {

                    return null;

                }

                this.labelExpression = ExpressionUtils.createExpression(labelFormula);

            }

            return this.labelExpression;

        }

        @Override

        public FeatureSymbolTable getFeatureSymbolTable() {

            if (this.featureSymbolTable == null) {

                DataManager dataManager = DALLocator.getDataManager();

                this.featureSymbolTable = dataManager.createFeatureSymbolTable();

                this.symbolTable = this.featureSymbolTable.createParent();

            }

            return this.featureSymbolTable;

        }

        @Override

        public SymbolTable getSymbolTable() {

            if (this.symbolTable == null) {

                DataManager dataManager = DALLocator.getDataManager();

                this.featureSymbolTable = dataManager.createFeatureSymbolTable();

                this.symbolTable = this.featureSymbolTable.createParent();

            }

            return this.symbolTable;

        }

    }

    private boolean foreingKey;

    private boolean selectable;

    private String labelFormula;

    private String tableName;

    private String codeName;

    private FeatureAttributeDescriptor descriptor;

    public DefaultForeingKey() {

    }

    public void setDescriptor(FeatureAttributeDescriptor descriptor) {

        this.descriptor = descriptor;

    }

    @Override

    public boolean isSelectable() {

        return this.selectable;

    }

    @Override

    public void setSelectable(boolean selectable) {

        this.selectable = selectable;

    }

    @Override

    public boolean isForeingKey() {

        return this.foreingKey;

    }

    @Override

    public void setForeingKey(boolean foreingKey) {

        this.foreingKey = foreingKey;

    }

    @Override

    public String getLabelFormula() {

        return this.labelFormula;

    }

    @Override

    public void setLabelFormula(String labelFormula) {

        this.labelFormula = labelFormula;

    }

    @Override

    public String getCodeName() {

        return this.codeName;

    }

    @Override

    public void setCodeName(String codeName) {

        this.codeName = codeName;

    }

    @Override

    public String getTableName() {

        return this.tableName;

    }

    @Override

    public void setTableName(String tableName) {

        this.tableName = tableName;

    }

    @Override

    public boolean isEmpty() {

        if (!this.foreingKey

                && !this.selectable

                && StringUtils.isBlank(this.tableName)

                && StringUtils.isBlank(this.codeName)

                && StringUtils.isBlank(this.labelFormula)) {

            return true;

        }

        return false;

    }

    @Override

    public void clean() {

        this.foreingKey = false;

        this.selectable = false;

        this.tableName = null;

        this.codeName = null;

        this.labelFormula = null;

    }

    private void disposeIfLocalContext(ContextForeingKey context) {

        DefaultContextForeingKey c = (DefaultContextForeingKey) context;

        c.relese();

        if( c.refs == 0 ) {

            context.dispose();

        }

    }

    private ContextForeingKey createLocalContextIfNull(ContextForeingKey context) {

        if (context == null) {

            return new DefaultContextForeingKey();

        }

        DefaultContextForeingKey c = (DefaultContextForeingKey) context;

        c.addRef();

        return c;

    }

    @Override

    public ContextForeingKey createContext() {

        return new DefaultContextForeingKey();

    }

    @Override

    public StoresRepository getStoresRepository(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getStoresRepository();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureStore getFeatureStore(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getFeatureStore();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureType getFeatureType(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        FeatureStore store = context.getFeatureStore();

        if (store == null) {

            return null;

        }

        try {

            return store.getDefaultFeatureType();

        } catch (DataException ex) {

            return null;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public List<Feature> getFeatures(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        FeatureStore store = context.getFeatureStore();

        if (store == null) {

            return null;

        }

        try {

            return store.getFeatures();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Object getCode(ContextForeingKey context, Feature feature) {

//        context = createLocalContextIfNull(context);

        try {

            return feature.get(codeName);

        } finally {

//            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureQuery getQuery(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            FeatureStore store = context.getFeatureStore();

            FeatureQuery query = store.createFeatureQuery();

            query.setFilter(builder.eq(

                    builder.variable(codeName),

                    builder.constant(codeValue)

            ).toString()

            );

            query.retrievesAllAttributes();

            return query;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Feature getFeature(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            FeatureStore store = context.getFeatureStore();

            if (store == null) {

                return null;

            }

            FeatureQuery query = this.getQuery(context, codeValue);

            Feature feature = store.findFirst(query);

            return feature;

        } catch (DataException ex) {

            return null;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public String getLabel(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            Feature feature = this.getFeature(context, codeValue);

            if (feature == null) {

                return null;

            }

            return getLabel(context, feature);

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Expression getLabelExpression(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getLabelExpression();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public String getLabel(ContextForeingKey context, Feature feature) {

        if (feature == null) {

            return null;

        }

        context = createLocalContextIfNull(context);

        try {

            Expression labelExpression = context.getLabelExpression();

            if (labelExpression == null) {

                return feature.toString();

            }

            context.getFeatureSymbolTable().setFeature(feature);

            Object x = labelExpression.execute(context.getSymbolTable());

            if (x == null) {

                return null;

            }

            return x.toString();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public DynObjectValueItem[] getAvailableValues(ContextForeingKey context) {

        if (!this.isSelectable()) {

            return null;

        }

        context = createLocalContextIfNull(context);

        try {

            Expression labelExpression = context.getLabelExpression();

            FeatureStore store = context.getFeatureStore();

            if (store == null) {

                return null;

            }

            int count = (int) store.getFeatureCount();

            DynObjectValueItem[] values = new DynObjectValueItem[Math.min(count, MAX_AVAILABLE_VALUES)];

            int n = 0;

            for (Feature feature : store.getFeatureSet()) {

                Object code = feature.get(codeName);

                Object value;

                if (labelExpression == null) {

                    value = code;

                } else {

                    context.getFeatureSymbolTable().setFeature(feature);

                    value = labelExpression.execute(context.getSymbolTable());

                }

                values[n++] = new DynObjectValueItem(code, Objects.toString(value, Objects.toString(code, "##ERROR##")));

                if( n>=MAX_AVAILABLE_VALUES ) {

                    break;

                }

            }

            return values;

        } catch (Exception ex) {

            LOGGER.warn("Can't get values from table '" + tableName + "' of field.", ex);

        } finally {

            disposeIfLocalContext(context);

        }

        return null;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        foreingKey = state.getBoolean("foreingKey");

        selectable = state.getBoolean("selectable");

        labelFormula = state.getString("labelFormula");

        codeName = state.getString("codeName");

        tableName = state.getString("tableName");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("foreingKey", foreingKey);

        state.set("selectable", selectable);

        state.set("labelFormula", labelFormula);

        state.set("codeName", codeName);

        state.set("tableName", tableName);

    }

    private static final String FOREINGKEY_PERSISTENCE_DEFINITION_NAME = "ForeingKey";

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(FOREINGKEY_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultForeingKey.class,

                    FOREINGKEY_PERSISTENCE_DEFINITION_NAME,

                    FOREINGKEY_PERSISTENCE_DEFINITION_NAME

                    + " persistent definition",

                    null,

                    null

            );

            definition.addDynFieldBoolean("foreingKey");

            definition.addDynFieldBoolean("selectable");

            definition.addDynFieldString("LabelFormula");

            definition.addDynFieldString("codeName");

            definition.addDynFieldString("tableName");

        }

    }

    @Override

    public ForeingKey clone() throws CloneNotSupportedException {

        DefaultForeingKey other = (DefaultForeingKey) super.clone();

        return other;

    }

}