/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/store/simplereader/SimpleReaderFeatureTypeLoader.java - Annotate - Application: gvSIG desktop - gvSIG

svn-gvsig-desktop / 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 / store / simplereader / SimpleReaderFeatureTypeLoader.java @ 47846

History | View | Annotate | Download (12.7 KB)

-            fdiaz
+/*
  * To change this license header, choose License Headers in Project Properties.
  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
 package org.gvsig.fmap.dal.store.simplereader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.util.Locale;
 import java.util.Map;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.gvsig.fmap.dal.DataTypes;
 import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
 import org.gvsig.fmap.dal.feature.EditableFeatureType;
-            jjdelcerro
+import org.gvsig.fmap.dal.store.simplereader.simplereaders.SimpleReader;
-            fdiaz
+import org.gvsig.tools.dynobject.Tags;
 import org.gvsig.tools.task.SimpleTaskStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 /**
+ *
  * @author fdiaz
  */
 public abstract class SimpleReaderFeatureTypeLoader {
     private static final Logger LOGGER = LoggerFactory.getLogger(SimpleReaderFeatureTypeLoader.class);
     protected boolean all_fields_declare_type;
-            fdiaz
+    protected SimpleReaderStoreParameters parameters;
             fdiaz
     public SimpleReaderFeatureTypeLoader(SimpleReaderStoreParameters parameters) {
         this.parameters = parameters;
+    }
-            fdiaz
+    protected SimpleReaderFeatureTypeLoader() {
         this.parameters = null;
+    }
-            fdiaz
+    protected abstract String getProviderName();
     protected abstract SimpleReader getSimpleReader(Reader in) throws IOException;
     protected FieldTypeParser[] getFieldTypes(String headers[], AutomaticDetectionOfTypes.DetectedValue automaticTypes[]) {
         String fullFileName = parameters.getFile()==null? "":parameters.getFile().getAbsolutePath();
         FieldTypeParser[] fieldTypes = new FieldTypeParser[headers.length];
         for (int i = 0; i < fieldTypes.length; i++) {
             fieldTypes[i] = new FieldTypeParser(getProviderName(), fullFileName);
+        }
         if (automaticTypes != null) {
             for (int i = 0; i < fieldTypes.length && i < automaticTypes.length; i++) {
                 fieldTypes[i].detectedValue = automaticTypes[i];
                 fieldTypes[i].type = automaticTypes[i].getType();
+            }
+        }
         this.all_fields_declare_type = true;
         for (int i = 0; i < fieldTypes.length; i++) {
             if (!fieldTypes[i].parse(headers[i])) {
                 LOGGER.warn("Can't parse header of field "+i+ "( "+headers[i]+") in '"+getProviderName()+"' file '" + fullFileName + "'.");
+            }
             if( fieldTypes[i].type == DataTypes.UNKNOWN ) {
                 all_fields_declare_type = false;
                 fieldTypes[i].type = DataTypes.STRING;
+            }
+        }
         String param_types_def = SimpleReaderStoreParameters.getRawFieldTypes(parameters);
         if (StringUtils.isNotBlank(param_types_def)) {
             String sep = SimpleReaderStoreParameters.getDelimiter(param_types_def);
             if (StringUtils.isNotBlank(sep)) {
                 String[] param_types = param_types_def.split(sep);
                 FieldTypeParser parser = new FieldTypeParser(getProviderName(), fullFileName);
                 for (String param_type : param_types) {
                     parser.clear();
                     parser.parse(param_type);
                     for (FieldTypeParser fieldType : fieldTypes) {
                         if (StringUtils.equalsIgnoreCase(fieldType.name, parser.name)) {
                             fieldType.copyFrom(parser);
                             break;
+                        }
+                    }
+                }
+            }
+        }
         return fieldTypes;
+    }
     protected void fillFeatureType(EditableFeatureType fType, FieldTypeParser[] fieldTypes) {
         String fullFileName = parameters.getFile()==null? "":parameters.getFile().getAbsolutePath();
         Tags ftypeTags = fType.getTags();
         for (FieldTypeParser fieldType : fieldTypes) {
             EditableFeatureAttributeDescriptor fad = fType.add(fieldType.name, fieldType.type);
             if( fieldType.detectedValue!=null ) {
                 fad.setDisplaySize(Math.max(fieldType.detectedValue.getDisplaySize(), fieldType.size));
                 fad.setSize(Math.max(fieldType.detectedValue.getDisplaySize(), fieldType.size));
                 if( fad.getPrecision()<fieldType.detectedValue.getPrecision() ) {
                     fad.setPrecision(fieldType.detectedValue.getPrecision());
+                }
                 if( fad.getScale()<fieldType.detectedValue.getScale()) {
                     fad.setScale(fieldType.detectedValue.getScale());
+                }
             } else {
                 fad.setDisplaySize(fieldType.size);
+            }
             if (fieldType.type == DataTypes.GEOMETRY ) {
                 fad.setGeometryType(fieldType.geomType, fieldType.geomSubtype);
                 if( fType.getDefaultGeometryAttributeName() == null ) {
                     fType.setDefaultGeometryAttributeName(fieldType.name);
+                }
+            }
             Locale locale = null;
             if (fieldType.type == DataTypes.TIMESTAMP ) {
                 if(!SimpleReaderStoreParameters.isBlankOrDefaultLocale(parameters)){
                     locale = SimpleReaderStoreParameters.getLocale(parameters);
+                }
             } else {
                 locale = SimpleReaderStoreParameters.getLocale(parameters);
+            }
             fad.setLocale(locale);
             for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {
                 try {
                     switch(entry.getKey().toLowerCase()) {
                         case "expression":
                             // Los campos calculados los procesamos en una segunda
                             // pasada, cuando ya estan definidos el resto de los campos
                             // ya que pueden requerir campos que aun no se han definido.
                             break;
                         default:
                                 fad.set(entry.getKey(), entry.getValue());
+                            }
                 } catch (Exception ex) {
                     LOGGER.warn("Can't set property '"+entry.getKey()+"' of '"+fad.getName()+"'.", ex);
+                }
+            }
             Tags tags = fad.getTags();
             for (Map.Entry<String, String> entry : fieldType.tags.entrySet()) {
                 tags.set(entry.getKey(), entry.getValue());
+            }
             for (Map.Entry<String, String> entry : fieldType.typetags.entrySet()) {
                 ftypeTags.set(entry.getKey(), entry.getValue());
+            }
             for (Map.Entry<String, String> entry : fieldType.typeAssignments.entrySet()) {
                 try {
                     fType.set(entry.getKey(), entry.getValue());
                 } catch(Exception ex) {
                     LOGGER.warn("Can't set attribute '"+entry.getKey()+"' in the feature type.", ex);
+                }
+            }
+        }
         // Processamos ahora los campos calculados
         for (FieldTypeParser fieldType : fieldTypes) {
             EditableFeatureAttributeDescriptor fad = fType.getEditableAttributeDescriptor(fieldType.name);
             for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {
                 try {
                     switch(entry.getKey().toLowerCase()) {
                         case "expression":
                             fad.set(entry.getKey(), entry.getValue());
                             break;
+                    }
                 } catch (Exception ex) {
                     LOGGER.warn("Can't set property '"+entry.getKey()+"' in '"+fad.getName()+"' of '"+fullFileName+"'.", ex);
+                }
+            }
+        }
+    }
-            fdiaz
+    public boolean loadFeatureType(EditableFeatureType featureType, SimpleTaskStatus status) throws IOException {
         return loadFeatureType(featureType, true, status);
+    }
-            fdiaz
+    public boolean loadFeatureType(EditableFeatureType featureType, boolean  detectTypes, SimpleTaskStatus status) throws IOException {
         InputStreamReader in = null;
         SimpleReader reader = null;
         try {
             in = SimpleReaderUtils.openFile(
                     parameters.getFile(),
                     SimpleReaderStoreParameters.getCharset(parameters)
             );
             reader = getSimpleReader(in);
             String[] headers = getHeaders(reader);
             AutomaticDetectionOfTypes.DetectedValue[] detectedTypes = null;
             if( detectTypes ) {
                 detectedTypes = automaticDetectionOfTypes(headers, status);
+            }
             if( StringUtils.isBlank(headers[headers.length-1]) &&
                 (detectedTypes==null || detectedTypes[headers.length-1].isBlank()) ) {
                 headers = ArrayUtils.remove(headers, headers.length-1);
-            fdiaz
+                if(detectedTypes != null) {
                     detectedTypes = ArrayUtils.remove(detectedTypes, detectedTypes.length-1);
+                }
             fdiaz
             if (detectedTypes != null && detectedTypes.length > headers.length) {
                 // Se han detectado mas columnas que las que hay en la cabezera,
                 // a?adimos mas columnas a la cabezera.
                 String[] headers2 = new String[detectedTypes.length];
                 for (int i = 0; i < headers2.length; i++) {
                     if (i < headers.length) {
                         headers2[i] = headers[i];
                     } else {
                         headers2[i] = getFixedHeader(i);
+                    }
+                }
                 headers = headers2;
+            }
             for (int i = 0; i < headers.length; i++) {
                 if (StringUtils.isBlank(headers[i])) {
                     headers[i] = getFixedHeader(i);
+                }
+            }
             // Initialize the feature types
             fillFeatureType(featureType,  headers, detectedTypes);
             return this.all_fields_declare_type;
         } finally {
             IOUtils.closeQuietly(in);
             IOUtils.closeQuietly(reader);
+        }
+    }
     protected String[] getHeaders(SimpleReader reader) throws RuntimeException, IOException {
         String headers[];
         headers = SimpleReaderStoreParameters.getHeaders(parameters);
         return headers;
+    }
     protected String[] getFixedHeaders(int count) {
         String[] headers = new String[count];
         for (int i = 0; i < headers.length; i++) {
             headers[i] = getFixedHeader(i);
+        }
         return headers;
+    }
     protected String getFixedHeader(int column) {
         char[] header = new char[3];
         String s = String.format("%03d", column);
         header[0] = (char) (s.charAt(0) + 17);
         header[1] = (char) (s.charAt(1) + 17);
         header[2] = (char) (s.charAt(2) + 17);
         return String.valueOf(header);
+    }
     private AutomaticDetectionOfTypes.DetectedValue[] automaticDetectionOfTypes(String[] headers, SimpleTaskStatus status) throws IOException {
         String fullFileName = parameters.getFile()==null? "NULL":parameters.getFile().getAbsolutePath();
         boolean automatic_types_detection = SimpleReaderStoreParameters.getAutomaticTypesDetection(parameters);
         if (!automatic_types_detection) {
             return null;
+        }
         AutomaticDetectionOfTypes.DetectedValue[] types = null;
         Reader in = null;
         SimpleReader reader = null;
         try {
             in = SimpleReaderUtils.openFile(
                     parameters.getFile(),
                     SimpleReaderStoreParameters.getCharset(parameters)
             );
             reader = getSimpleReader(in);
             AutomaticDetectionOfTypes x = new AutomaticDetectionOfTypes(
                     fullFileName
             );
             types = x.detect(
                     headers.length,
                     reader,
                     isFirstLineHeader(),
                     SimpleReaderStoreParameters.getLocale(parameters),
                     status
             );
         } catch (Exception ex) {
             int lineno = 0;
             if (reader != null) {
                 lineno = reader.getLine();
+            }
             throw new RuntimeException("Problems reading file '" + fullFileName + "' near line " + lineno + ".", ex);
         } finally {
             IOUtils.closeQuietly(reader);
             IOUtils.closeQuietly(in);
+        }
         return types;
+    }
     protected boolean isFirstLineHeader() {
         return false;
+    }
-            jjdelcerro
+    protected void fillFeatureType(EditableFeatureType fType, String headers[], AutomaticDetectionOfTypes.DetectedValue automaticTypes[]) {
-            fdiaz
+        fType.setHasOID(true);
         FieldTypeParser[] fieldTypes = getFieldTypes(headers, automaticTypes);
         fillFeatureType(fType, fieldTypes);
+    }
-            jjdelcerro
+    public boolean isAllFieldsDeclareType() {
         return this.all_fields_declare_type;
+    }
             fdiaz