/trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.file/org.gvsig.fmap.dal.file.lib/src/main/java/org/gvsig/fmap/dal/feature/spi/simpleprovider/SimpleSequentialReaderStoreProvider.java - Diff - Application: gvSIG desktop - gvSIG

Revision 44259 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.file/org.gvsig.fmap.dal.file.lib/src/main/java/org/gvsig/fmap/dal/feature/spi/simpleprovider/SimpleSequentialReaderStoreProvider.java

     import java.io.File;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.Collections;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Locale;
     import java.util.Map;
     import org.apache.commons.io.FilenameUtils;
     import org.apache.commons.lang3.StringUtils;
     import org.cresques.cts.IProjection;
-...
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.task.SimpleTaskStatus;
     import org.gvsig.tools.task.TaskStatusManager;
     import org.gvsig.tools.util.UnmodifiableBasicMap;
     import org.gvsig.tools.util.UnmodifiableBasicMapToMapAdapter;
     import org.gvsig.tools.util.UnmodifiableBasicSet;
     import org.gvsig.tools.visitor.VisitCanceledException;
     import org.gvsig.tools.visitor.Visitor;
     import org.slf4j.Logger;
-...
         private class ReaderData {
             private FeatureType defaultFeatureType;
             private List<FeatureType> featureTypes;
             private List<FeatureProvider> features;
             private final List<FeatureProvider> features;
             private boolean needCalculateEnvelope;
             private String name;
             private long OIDcounter;
-...
                 return this.store;
+            }
+        }
         class Children implements UnmodifiableBasicMap<String, DataStore> {
             // Con esta clase se pospone la creacion de los stores hasta que se
             // pide cada uno de ellos, y no cuando se pide el Map de estos, ya
             // que el map se puede pedir solo para saber si hay o cuantos hay.
             @Override
             public DataStore get(String key) {
                 for (ReaderData child : childrenData) {
                     if( StringUtils.equalsIgnoreCase(child.getName(), key) ) {
                         try {
                             return child.getStore();
                         } catch (Exception ex) {
                             throw new RuntimeException(ex);
+                        }
+                    }
+                }
                 return null;
+            }
             @Override
             public boolean isEmpty() {
                 return childrenData.isEmpty();
+            }
             @Override
             public boolean containsKey(String key) {
                 for (ReaderData child : childrenData) {
                     if( StringUtils.equalsIgnoreCase(child.getName(), key) ) {
                         return true;
+                    }
+                }
                 return false;
+            }
             @Override
             public Map<String, DataStore> toMap() {
                 return new UnmodifiableBasicMapToMapAdapter<>(this);
+            }
             @Override
             public int size() {
                 return childrenData.size();
+            }
             @Override
             public UnmodifiableBasicSet<String> keySet() {
                 return new UnmodifiableBasicSet<String>() {
                     @Override
                     public boolean isEmpty() {
                         return childrenData.isEmpty();
+                    }
                     @Override
                     public int size() {
                         return childrenData.size();
+                    }
                     @Override
                     public Iterator<String> iterator() {
                         final Iterator<ReaderData> it = childrenData.iterator();
                         return new Iterator<String>() {
                             @Override
                             public boolean hasNext() {
                                 return it.hasNext();
+                            }
                             @Override
                             public String next() {
                                 ReaderData theReaderData = it.next();
                                 return theReaderData.getName();
+                            }
                         };
+                    }
                 };
+            }
             @Override
             public Iterator<DataStore> iterator() {
                 final Iterator<String> it = this.keySet().iterator();
                 return new Iterator<DataStore>() {
                     @Override
                     public boolean hasNext() {
                         return it.hasNext();
+                    }
                     @Override
                     public DataStore next() {
                         String name = it.next();
                         return get(name);
+                    }
                 };
+            }
+        }
         private final ResourceProvider resource;
         private Envelope envelope;
-...
         private final SimpleTaskStatus taskStatus;
         private String name = "";
         private final SimpleSequentialReaderFactory readerFactory;
         private final List<ReaderData> childrenData;
         private List<ReaderData> childrenData;
         private ReaderData readerData;
         public SimpleSequentialReaderStoreProvider(
-...
             );
             resource.addConsumer(this);
             if( this.readerData!=null ) {
                 this.name = this.readerData.getName();
+            }
             if( storeServices != null ) {
                 initializeFeatureTypes();
+            }
-...
                                 break;
+                            }
                         default:
                             LOGGER.warn("Illegal argumente '"+option+"' in '"+getProviderName()+"' file '" + getFullFileName() + "'.");
                             LOGGER.warn("Illegal argumente '"+option+"' for field '"+this.name+"' in '"+getProviderName()+"' file '" + getFullFileName() + "' ("+value+").");
+                    }
+                }
                 return true;
-...
                 SimpleSequentialReader reader = this.readerFactory.createReader(this.getParameters());
                 try {
                     loadFeatures(reader, theReaderData);
                     this.childrenData = new ArrayList<>();
                     for(SimpleSequentialReader childReader : reader.getChildren() ) {
                         ReaderData childData = new ReaderData();
                         loadFeatures(childReader, childData);
-...
+                }
+            }
             this.name = theReaderData.getName();
             FeatureStoreProviderServices store = this.getStoreServices();
             store.setFeatureTypes(theReaderData.getFeatureTypes(), theReaderData.getDefaultFeatureType());
             FeatureStoreProviderServices theStore = this.getStoreServices();
             theStore.setFeatureTypes(theReaderData.getFeatureTypes(), theReaderData.getDefaultFeatureType());
             this.need_calculate_envelope = theReaderData.getNeedCalculateEnvelope();
             this.data = theReaderData.getFeatures();
-...
+        }
         @Override
         public DataStore getChild(String name) {
             for (ReaderData childData : this.childrenData) {
                 if( StringUtils.equalsIgnoreCase(name, childData.getName()) ) {
                     try {
                         return childData.getStore();
                     } catch (InitializeException ex) {
                         throw new RuntimeException("Can't acces to child '"+name+"'", ex);
+                    }
+                }
+            }
             return null;
         public UnmodifiableBasicMap<String, DataStore> getChildren() {
             return new Children();
+        }
         @Override
         public Iterator<DataStore> getChildren() {
             if( this.childrenData==null || this.childrenData.isEmpty() ) {
                 return Collections.EMPTY_LIST.iterator();
+            }
             try {
                 List<DataStore> children = new ArrayList<>();
                 for (ReaderData childData : this.childrenData) {
                         children.add(childData.getStore());
+                }
                 return children.iterator();
             } catch (InitializeException ex) {
                 throw new RuntimeException("Can't access to children", ex);
+            }
+        }
         @Override
         public boolean hasChildren() {
             return this.childrenData!=null && !this.childrenData.isEmpty();
+        }
+    }

Also available in: Unified diff