Application: gvSIG desktop

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

import java.util.AbstractList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

import org.gvsig.fmap.dal.feature.spi.memory.MemoryResource;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.spi.DataStoreInitializer2;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.dal.store.memory.MemoryStoreParameters;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.timesupport.Time;

/**

 *

 * @author jjdelcerro

 */

public class FeatureTypeToStoreProviderAdapter extends AbstractMemoryStoreProvider {

    private static final String NAME = "FeatureType";

    private static final int ATTR_NAME = 0;

    private static final int ATTR_TYPE = 1;

    private static final int ATTR_TYPENAME = 2;

    private static final int ATTR_SIZE = 3;

    private static final int ATTR_PRECISION = 4;

    private static final int ATTR_LABEL = 5;

    private static final int ATTR_SHORTLABEL = 6;

    private static final int ATTR_DESCRIPTION = 7;

    private static final int ATTR_PROFILE = 8;

    private static final int ATTR_GROUP = 9;

    private static final int ATTR_ORDER = 10;

    private static final int ATTR_ISPK = 11;

    private static final int ATTR_ISFK = 12;

    private static final int ATTR_ISCLOSEDLIST = 13;

    private static final int ATTR_ISREADONLY = 14;

    private static final int ATTR_ISCOMPUTED = 15;

    private static final int ATTR_ISCAUTOMATIC = 16;

    private static final int ATTR_ISHIDDEN = 17;

    private static final int ATTR_ALLOWNULLS = 18;

    private static final int ATTR_EXPRESSION = 19;

    private static final int ATTR_FKTABLE = 20;

    private static final int ATTR_FKCODE = 21;

    private static final int ATTR_FKLABEL = 22;

    private static Map<String,Integer> attrName2Index;

    private static FeatureType featureTypeOfFeatureType;

    private static class Features

            extends AbstractList<FeatureProvider>

            implements List<FeatureProvider>

        {

        private static class MyFeatureProvider implements FeatureProvider {

            private FeatureAttributeDescriptor descriptor;

            public MyFeatureProvider(FeatureAttributeDescriptor descriptor) {

                this.descriptor = descriptor;

            }

            @Override

            public boolean isReadOnly(int i) {

                return true;

            }

            @Override

            public void set(int i, Object value) {

            }

            @Override

            public Object get(int i) {

                switch(i) {

                    case ATTR_NAME:

                        return this.descriptor.getName();

                    case ATTR_SIZE:

                        return this.descriptor.getSize();

                    case ATTR_TYPE:

                        return this.descriptor.getType();

                    case ATTR_TYPENAME:

                        return this.descriptor.getDataTypeName();

                    case ATTR_PRECISION:

                        return this.descriptor.getPrecision();

                    case ATTR_SHORTLABEL:

                        return this.descriptor.getShortLabel();

                    case ATTR_LABEL:

                        return this.descriptor.getLabel();

                    case ATTR_DESCRIPTION:

                        return this.descriptor.getDescription();

                    case ATTR_PROFILE:

                        return this.descriptor.getDataProfileName();

                    case ATTR_GROUP:

                        return this.descriptor.getGroup();

                    case ATTR_ORDER:

                        return this.descriptor.getOder();

                    case ATTR_ISPK:

                        return this.descriptor.isPrimaryKey();

                    case ATTR_ISFK:

                        return this.descriptor.isForeingKey();

                    case ATTR_ISCLOSEDLIST:

                        if( this.descriptor.isForeingKey() ) {

                            return this.descriptor.getForeingKey().isClosedList();

                        }

                        return false;

                    case ATTR_ISREADONLY:

                        return this.descriptor.isReadOnly();

                    case ATTR_ISCOMPUTED:

                        return this.descriptor.isComputed();

                    case ATTR_ISCAUTOMATIC:

                        return this.descriptor.isAutomatic();

                    case ATTR_ISHIDDEN:

                        return this.descriptor.isHidden();

                    case ATTR_ALLOWNULLS:

                        return this.descriptor.allowNull();

                    case ATTR_EXPRESSION: {

                        FeatureAttributeEmulator x = this.descriptor.getFeatureAttributeEmulator();

                        if( x instanceof FeatureAttributeEmulatorExpression ) {

                            Expression exp = ((FeatureAttributeEmulatorExpression) x).getExpression();

                            if( exp != null ) {

                                return exp.getPhrase();

                            }

                        }

                        return null;

                    }

                    case ATTR_FKTABLE:

                        if( this.descriptor.isForeingKey() ) {

                            return this.descriptor.getForeingKey().getTableName();

                        }

                        return null;

                    case ATTR_FKCODE:

                        if( this.descriptor.isForeingKey() ) {

                            return this.descriptor.getForeingKey().getCodeName();

                        }

                        return null;

                    case ATTR_FKLABEL:

                        if( this.descriptor.isForeingKey() ) {

                            return this.descriptor.getForeingKey().getLabelFormula();

                        }

                        return null;

                    default:

                        return null;

                }

            }

            @Override

            public void set(String name, Object value) {

            }

            @Override

            public Object get(String name) {

                int n = attrName2Index.get(name);

                return this.get(n);

            }

            @Override

            public void setOID(Object oid) {

            }

            @Override

            public Object getOID() {

                return this.descriptor.getIndex();

            }

            @Override

            public FeatureType getType() {

                return featureTypeOfFeatureType;

            }

            @Override

            public FeatureProvider getCopy() {

                return this;

            }

            @Override

            public Envelope getDefaultEnvelope() {

                return null;

            }

            @Override

            public Geometry getDefaultGeometry() {

                return null;

            }

            @Override

            public Time getDefaultTime() {

                return null;

            }

            @Override

            public void setDefaultEnvelope(Envelope extent) {

            }

            @Override

            public void setDefaultGeometry(Geometry geom) {

            }

            @Override

            public void setDefaultTime(Time time) {

            }

            @Override

            public boolean isNull(int i) {

                return false;

            }

            @Override

            public boolean isNull(String name) {

                return false;

            }

            @Override

            public boolean isNew() {

                return false;

            }

            @Override

            public void setNew(boolean isNew) {

            }

            @Override

            public void setExtraValue(int index, Object value) {

            }

            @Override

            public Object getExtraValue(int index) {

                return null;

            }

            @Override

            public Object getExtraValue(String name) {

                return null;

            }

            @Override

            public void setExtraValueNames(String[] extraValueNames) {

            }

        }

        private final FeatureType featureType;

        public Features(FeatureType featureType) {

            this.featureType = featureType;

        }

        @Override

        public FeatureProvider get(int index) {

            return new MyFeatureProvider(this.featureType.get(index));

        }

        @Override

        public int size() {

            return this.featureType.size();

        }

    }

    private final FeatureType featureType;

    private final ResourceProvider resource;

    private final Double sourceID;

    private FeatureTypeToStoreProviderAdapter(

            DataStoreParameters parameters,

            DataStoreProviderServices storeServices,

            FeatureType featureType

        ) throws InitializeException {

        super(parameters, storeServices);

        this.featureType = featureType;

        this.data = new Features(featureType);

        this.sourceID = Math.random();

        this.resource = createResource(

                MemoryResource.NAME,

                new Object[] { NAME }

        );

        if( featureTypeOfFeatureType==null ) {

            this.initFeatureType();

        }

        this.getStoreServices().setFeatureTypes(

                Collections.singletonList(featureTypeOfFeatureType), 

                featureTypeOfFeatureType

        );

    }

    public static FeatureStore createFeatureStore(FeatureType featureType) {

        try {

            DataStoreParameters parameters = FeatureTypeToStoreProviderAdapter.getParameters(featureType);

            DefaultFeatureStore store = new DefaultFeatureStore();

            DataStoreProvider provider = new FeatureTypeToStoreProviderAdapter(

                    parameters,

                    store,

                    featureType

            );

            store.intialize(DALLocator.getDataManager(), parameters);

            ((DataStoreInitializer2)store).setProvider(provider);

            return store;

        } catch (Exception ex) {

            return null;

        }

    }

    private void initFeatureType() {

        if( featureTypeOfFeatureType!=null ) {

            return;

        }

        EditableFeatureType ft = this.getStoreServices().createFeatureType(

                getName()

        );

        ft.setHasOID(true);

        ft.add("name", DataTypes.STRING, 100);

        ft.add("type", DataTypes.INT, 0);

        ft.add("typeName", DataTypes.STRING, 100);

        ft.add("size", DataTypes.INT, 0);

        ft.add("precision", DataTypes.INT, 0);

        ft.add("label", DataTypes.STRING, 100);

        ft.add("shortlabel", DataTypes.STRING, 100);

        ft.add("description", DataTypes.STRING, 1024);

        ft.add("profile", DataTypes.STRING, 100);

        ft.add("group", DataTypes.STRING, 100);

        ft.add("order", DataTypes.INT, 0);

        ft.add("isPk", DataTypes.BOOLEAN, 0);

        ft.add("isFk", DataTypes.BOOLEAN, 0);

        ft.add("isClosedList", DataTypes.BOOLEAN, 0);

        ft.add("isReadOnly", DataTypes.BOOLEAN, 0);

        ft.add("isComputed", DataTypes.BOOLEAN, 0);

        ft.add("isAutomatic", DataTypes.BOOLEAN, 0);

        ft.add("isHidden", DataTypes.BOOLEAN, 0);

        ft.add("allowNulls", DataTypes.BOOLEAN, 0);

        ft.add("expression", DataTypes.STRING, 1024);

        ft.add("fkTable", DataTypes.STRING, 100);

        ft.add("fkCode", DataTypes.STRING, 100);

        ft.add("fkLabel", DataTypes.STRING, 1024);

        featureTypeOfFeatureType = ft;

        attrName2Index = new HashMap<>();

        for (FeatureAttributeDescriptor attr : ft) {

            attrName2Index.put(attr.getName(), attr.getIndex());

        }

    }

    private static MemoryStoreParameters getParameters(FeatureType featureType) {

        MemoryStoreParameters params = new MemoryStoreParameters(NAME);

        params.setDynValue(MemoryStoreParameters.ORDER_PARAMETER_NAME, "name");

        return params;

    }

    @Override

    public void open() throws OpenException {

    }

    @Override

    public FeatureProvider createFeatureProvider(FeatureType featureType)throws DataException  {

            return null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public final Object getSourceId() {

        return this.sourceID;

    }

    @Override

    public final String getProviderName() {

        return NAME;

    }

    @Override

    public final String getName() {

        return this.featureType.getStore().getName() + "!" + this.featureType.getId();

    }

    @Override

    public final String getFullName() {

        return this.featureType.getStore().getFullName()+ "!" + this.featureType.getId();

    }

    @Override

    public Object createNewOID() {

        return null;

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

}