Revision 47740

View differences:

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.mapcontext/org.gvsig.fmap.mapcontext.api/src/main/java/org/gvsig/fmap/mapcontext/MapContextManager.java
52 52
import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;
53 53
import org.gvsig.raster.lib.legend.api.RasterLegend;
54 54
import org.gvsig.tools.observer.Observable;
55
import org.gvsig.tools.util.Factory;
55 56

  
56 57
/**
57 58
 * Manager of the MapContext library.
......
96 97
    public MapContext createMapContext();
97 98

  
98 99
    public boolean registerLayer(
99
            Class theClass, // DataStoreClass, DataParametersClass
100
            Class<? extends FLayer> layerClass);
100
            Class theClass, 
101
            Class<? extends FLayer> layerClass
102
    );
101 103

  
104
    public boolean registerLayer(Factory<FLayer> factory);
105

  
102 106
    /**
103 107
     * Create a new layer from the data parameters passed as parameter.
104 108
     *
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.mapcontext/org.gvsig.fmap.mapcontext.api/src/main/java/org/gvsig/fmap/mapcontext/impl/DefaultMapContextManager.java
102 102
import org.gvsig.tools.resourcesstorage.ResourcesStorage;
103 103
import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;
104 104
import org.gvsig.tools.swing.api.TransparencySupport;
105
import org.gvsig.tools.util.Factory;
105 106
import org.slf4j.Logger;
106 107
import org.slf4j.LoggerFactory;
107 108

  
......
125 126

  
126 127
    private final Map<String, Map<Class<ILegend>,Class<ILegendWriter>>> legendWriters = new LinkedHashMap<>();
127 128
    
128
    private final Map<Class,Class<? extends FLayer>> layerClassFromStoreClass = new HashMap<>();
129
    private final Map<Object,Class<? extends FLayer>> layerClassFromStoreClass = new HashMap<>();
129 130

  
130 131
    private final Map<String,String> iconLayers = new HashMap(); //  (Map<String storeProviderName, String iconName>)
131 132

  
......
691 692
        this.layerClassFromStoreClass.put(theClass, layerClass);
692 693
        return true;
693 694
    }    
695

  
696
    @Override
697
    public boolean registerLayer(Factory<FLayer> factory) {
698
        this.layerClassFromStoreClass.put(factory, null);
699
        return true;
700
    }
694 701
    
702
    private FLayer newLayer(DataStore dataStore) {
703
        for (Map.Entry<Object, Class<? extends FLayer>> entry : layerClassFromStoreClass.entrySet()) {
704
            Object  currentKey = entry.getKey();
705
            if( currentKey instanceof Factory ) {
706
                Factory<FLayer> factory = (Factory<FLayer>) currentKey;
707
                FLayer layer = factory.create(dataStore.getParameters(), dataStore);
708
                if( layer != null ) {
709
                    return layer;
710
                }
711
            }
712
        }
713
        return null;
714
    }
715
    
695 716
    private Class<? extends FLayer> getLayerClass(
696 717
            Class keyClass) {
697 718
        Class<? extends FLayer> layerClass = this.layerClassFromStoreClass.get(keyClass);
698 719
        if( layerClass!=null ) {
699 720
            return layerClass;
700 721
        }
701
        for (Map.Entry<Class, Class<? extends FLayer>> entry : layerClassFromStoreClass.entrySet()) {
702
            Class  currentKeyClass = entry.getKey();
703
            layerClass = entry.getValue();
704
            if( currentKeyClass.isAssignableFrom(keyClass) ) {
705
                return layerClass;
722
        for (Map.Entry<Object, Class<? extends FLayer>> entry : layerClassFromStoreClass.entrySet()) {
723
            Object  currentKey = entry.getKey();
724
            if( currentKey instanceof Class ) {
725
                Class  currentKeyClass = (Class) currentKey;
726
                layerClass = entry.getValue();
727
                if( currentKeyClass.isAssignableFrom(keyClass) ) {
728
                    return layerClass;
729
                }
706 730
            }
707 731
        }
708 732
        return null;
......
814 838
                    }
815 839
                }
816 840
            }
817
            
818
            Class<? extends FLayer> layerClass = this.getLayerClass(dataStore.getParameters().getClass());
819
            if (layerClass == null) {
820
                layerClass = this.getLayerClass(dataStore.getProviderFactory().getClass());
841
            FLayer layer = this.newLayer(dataStore);
842
            if( layer == null ) {
843
                Class<? extends FLayer> layerClass = this.getLayerClass(dataStore.getParameters().getClass());
821 844
                if (layerClass == null) {
822
                    layerClass = this.getLayerClass(dataStore.getClass());
845
                    layerClass = this.getLayerClass(dataStore.getProviderFactory().getClass());
846
                    if (layerClass == null) {
847
                        layerClass = this.getLayerClass(dataStore.getClass());
848
                    }
849
                    if (layerClass == null) {
850
                        throw new CantRetrieveLayerByStoreException(layerName, dataStore.getName());
851
                    }
823 852
                }
824
                if (layerClass == null) {
825
                    throw new CantRetrieveLayerByStoreException(layerName, dataStore.getName());
853
                try {
854
                    layer = (FLayer) layerClass.newInstance();
855
                } catch (InstantiationException | IllegalAccessException e) {
856
                    throw new LoadLayerException(layerName, e);
826 857
                }
827 858
            }
828
            FLayer layer;
829
            try {
830
                layer = (FLayer) layerClass.newInstance();
831
            } catch (InstantiationException | IllegalAccessException e) {
832
                throw new LoadLayerException(layerName, e);
833
            }
834

  
835 859
            layer.setName(layerName);
836 860
            ((SingleLayer) layer).setDataStore(dataStore);
837 861
            if (projection != null) {

Also available in: Unified diff