/trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/DefaultEditableFeatureAttributeDescriptor.java - Diff - Application: gvSIG desktop - gvSIG

Revision 45739 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/DefaultEditableFeatureAttributeDescriptor.java

     import org.gvsig.tools.evaluator.Evaluator;
     public class DefaultEditableFeatureAttributeDescriptor extends
         DefaultFeatureAttributeDescriptor implements
         EditableFeatureAttributeDescriptor {
             DefaultFeatureAttributeDescriptor implements
             EditableFeatureAttributeDescriptor {
         private static Logger logger = LoggerFactory.getLogger(
             DefaultEditableFeatureAttributeDescriptor.class);
                 DefaultEditableFeatureAttributeDescriptor.class);
         private final DefaultFeatureAttributeDescriptor source;
         private boolean hasStrongChanges;
         private String originalName = null;
         protected DefaultEditableFeatureAttributeDescriptor(
             DefaultFeatureAttributeDescriptor other) {
                 DefaultFeatureAttributeDescriptor other) {
             super(other);
             if (other instanceof DefaultEditableFeatureAttributeDescriptor) {
                 DefaultEditableFeatureAttributeDescriptor other_edi =
                     (DefaultEditableFeatureAttributeDescriptor) other;
                 DefaultEditableFeatureAttributeDescriptor other_edi
                         = (DefaultEditableFeatureAttributeDescriptor) other;
                 originalName = other_edi.getOriginalName();
                 this.source = other_edi.getSource();
             } else {
-...
         public DefaultFeatureAttributeDescriptor getSource() {
             return this.source;
+        }
         public void fixAll() {
             super.fixAll();
+        }
         public void checkIntegrity() throws AttributeFeatureTypeIntegrityException {
             AttributeFeatureTypeIntegrityException ex =
                 new AttributeFeatureTypeIntegrityException(getName());
             AttributeFeatureTypeIntegrityException ex
                     = new AttributeFeatureTypeIntegrityException(getName());
             if (this.size < 0) {
                 ex.add(new AttributeFeatureTypeSizeException(this.size));
+            }
             if( this.dataType.isObject() && this.objectClass == null ) {
             if (this.dataType.isObject() && this.objectClass == null) {
                 logger.warn("Incorrect data type object, objectClass is null.");
                 ex.add(new AttributeFeatureTypeIntegrityException(this.name));
+            }
             // TODO: Add other integrity checks...
             if (ex.size() > 0) {
                 throw ex;
+            }
-...
             this.allowNull = allowNull;
             return this;
+        }
         @Override
         public EditableForeingKey getForeingKey() {
             if( this.foreingKey==null ) {
             if (this.foreingKey == null) {
                 this.foreingKey = new DefaultForeingKey();
                 this.foreingKey.setDescriptor(this);
+            }
-...
             this.dataType = dataType;
             return this;
+        }
         public EditableFeatureAttributeDescriptor setDataType(int type) {
             updateStrongChanges(this.dataType, type);
             this.dataType = ToolsLocator.getDataTypesManager().get(type);
-...
+        }
         public EditableFeatureAttributeDescriptor setDefaultValue(
             Object defaultValue) {
                 Object defaultValue) {
             updateStrongChanges(this.defaultValue, defaultValue);
             this.defaultValue = defaultValue;
             return this;
-...
             this.avoidCachingAvailableValues = avoidCachingAvailableValues;
             return this;
+        }
         public EditableFeatureAttributeDescriptor setEvaluator(Evaluator evaluator) {
             updateStrongChanges(this.evaluator, evaluator);
             this.evaluator = evaluator;
-...
             this.featureAttributeEmulator = featureAttributeEmulator;
             return this;
+        }
         @Override
         public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(Expression expression) {
             if( ExpressionUtils.isPhraseEmpty(expression) ) {
                 this.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);
             if (ExpressionUtils.isPhraseEmpty(expression)) {
                 this.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);
                 return this;
+            }
+            }
             FeatureAttributeEmulatorExpression emulator = DALLocator.getDataManager().createFeatureAttributeEmulatorExpression(
                     this.getFeatureType(),
                     expression
-...
         @Override
         public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(String expression) {
             if( StringUtils.isBlank(expression) ) {
                 this.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);
             if (StringUtils.isBlank(expression)) {
                 this.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);
                 return this;
+            }
+            }
             return this.setFeatureAttributeEmulator(ExpressionUtils.createExpression(expression));
+        }
         @Override
         public EditableFeatureAttributeDescriptor setGeometryType(int type) {
             this.geometryType = type;
             if( this.geometrySubType == Geometry.SUBTYPES.UNKNOWN ) {
             if (this.geometrySubType == Geometry.SUBTYPES.UNKNOWN) {
                 this.geometrySubType = Geometry.SUBTYPES.GEOM2D;
+            }
             this.geomType = null;
-...
+        }
         public EditableFeatureAttributeDescriptor setGeometryType(
             GeometryType geometryType) {
                 GeometryType geometryType) {
             updateStrongChanges(this.geomType, geometryType);
             this.geomType = geometryType;
             this.geometryType = this.geomType.getType();
-...
         @Override
         public EditableFeatureAttributeDescriptor setGeometryType(String geometryType) {
             if( StringUtils.isBlank(geometryType) ) {
             if (StringUtils.isBlank(geometryType)) {
                 throw new IllegalArgumentException("Invalid geometry type (null)");
+            }
             String separators = ":/-!;#@";
             Character sep = null;
             for (char ch : separators.toCharArray()) {
                 if( geometryType.indexOf(ch)>=0 ) {
                 if (geometryType.indexOf(ch) >= 0) {
                     sep = ch;
                     break;
+                }
+            }
             if( sep == null ) {
                 throw new IllegalArgumentException("Invalid geometry type ("+geometryType+") can't find separator, format can be GEOMETRYTYPE["+separators+"]GEOMETRYSUBTYPE");
             if (sep == null) {
                 throw new IllegalArgumentException("Invalid geometry type (" + geometryType + ") can't find separator, format can be GEOMETRYTYPE[" + separators + "]GEOMETRYSUBTYPE");
+            }
             String[] xx = geometryType.split("["+sep+"]");
             String[] xx = geometryType.split("[" + sep + "]");
             int theGeomType = GeometryUtils.getGeometryType(xx[0]);
             int theGeomSubtype = GeometryUtils.getGeometrySubtype(xx[1]);
             this.setGeometryType(theGeomType, theGeomSubtype);
             return this;
+        }
         @Override
         public EditableFeatureAttributeDescriptor setGeometryType(int type, int subType) {
             this.geometryType = type;
-...
+        }
         public EditableFeatureAttributeDescriptor setIsPrimaryKey(
             boolean isPrimaryKey) {
                 boolean isPrimaryKey) {
             updateStrongChanges(this.primaryKey, primaryKey);
             this.primaryKey = isPrimaryKey;
             return this;
-...
+        }
         public EditableFeatureAttributeDescriptor setMaximumOccurrences(
             int maximumOccurrences) {
                 int maximumOccurrences) {
             updateStrongChanges(this.maximumOccurrences, maximumOccurrences);
             this.maximumOccurrences = maximumOccurrences;
             return this;
+        }
         public EditableFeatureAttributeDescriptor setMinimumOccurrences(
             int minimumOccurrences) {
                 int minimumOccurrences) {
             updateStrongChanges(this.minimumOccurrences, minimumOccurrences);
             this.minimumOccurrences = minimumOccurrences;
             return this;
-...
         @Override
         public EditableFeatureAttributeDescriptor setName(String name) {
             if( StringUtils.equals(this.name, name) ) {
             if (StringUtils.equals(this.name, name)) {
                 return this;
+            }
             if (originalName == null) {
-...
+            }
             return this;
+        }
         public String getOriginalName() {
             return originalName;
+        }
-...
         @Override
         public EditableFeatureAttributeDescriptor setSRS(String SRS) {
             if( StringUtils.isBlank(SRS) ) {
                 this.setSRS((IProjection)null);
             if (StringUtils.isBlank(SRS)) {
                 this.setSRS((IProjection) null);
                 return this;
+            }
             SRS = SRS.replace('@', ':');
-...
             this.setSRS(proj);
             return this;
+        }
         public EditableFeatureAttributeDescriptor setInterval(Interval interval) {
             updateStrongChanges(this.getInterval(), interval);
             super.setInterval(interval);
-...
         @Override
         public EditableFeatureAttributeDescriptor setAdditionalInfo(
             String infoName, Object value) {
                 String infoName, Object value) {
             return this.setAdditionalInfo(infoName, Objects.toString(value, ""));
+        }
         public EditableFeatureAttributeDescriptor setAdditionalInfo(
             String infoName, String value) {
                 String infoName, String value) {
             if (this.additionalInfo == null) {
                 this.additionalInfo = new HashMap();
+            }
-...
         public EditableFeatureAttributeDescriptor setIsAutomatic(boolean isAutomatic) {
             this.isAutomatic = isAutomatic;
             if( isAutomatic ) {
             if (isAutomatic) {
                 this.setReadOnly(true);
+            }
             return this;
+        }
         public EditableFeatureAttributeDescriptor setIsTime(boolean isTime) {
             updateStrongChanges(this.isTime, isTime);
             this.isTime = isTime;
-...
             this.indexed = isIndexed;
             return this;
+        }
         public EditableFeatureAttributeDescriptor setAllowIndexDuplicateds(boolean allowDuplicateds) {
             updateStrongChanges(this.allowIndexDuplicateds, allowDuplicateds);
             this.allowIndexDuplicateds = allowDuplicateds;
-...
+        }
         private void updateStrongChanges(int previous, int newvalue) {
             if( isComputed() ) {
             if (isComputed()) {
                 return;
+            }
             if( previous == newvalue ) {
             if (previous == newvalue) {
                 return;
+            }
             this.hasStrongChanges = true;
+        }
         private void updateStrongChanges(DataType previous, int newvalue) {
             if( isComputed() ) {
             if (isComputed()) {
                 return;
+            }
             if( previous!=null ) {
                 if( previous.getType() == newvalue ) {
             if (previous != null) {
                 if (previous.getType() == newvalue) {
                     return;
+                }
+            }
-...
+        }
         private void updateStrongChanges(boolean previous, boolean newvalue) {
             if( isComputed() ) {
             if (isComputed()) {
                 return;
+            }
             if( previous == newvalue ) {
             if (previous == newvalue) {
                 return;
+            }
             this.hasStrongChanges = true;
+        }
         private void updateStrongChanges(Object previous, Object newvalue) {
             if( isComputed() ) {
             if (isComputed()) {
                 return;
+            }
             if( Objects.equals(newvalue, previous) ) {
             if (Objects.equals(newvalue, previous)) {
                 return;
+            }
             this.hasStrongChanges = true;
-...
         @Override
         public EditableFeatureAttributeDescriptor setLocale(Locale locale) {
           if( locale == null ) {
             this.locale = Locale.ENGLISH;
           } else {
             this.locale = locale;
+          }
           this.coerceContext = null;
           this.mathContext = null;
           return this;
             if (locale == null) {
                 this.locale = Locale.ENGLISH;
             } else {
                 this.locale = locale;
+            }
             this.coerceContext = null;
             this.mathContext = null;
             return this;
+        }
         public EditableFeatureAttributeDescriptor setLocale(String locale) {
           Locale l;
           try {
             String s = DataTypeUtils.toString(locale, null);
             if( StringUtils.isBlank(s) ) {
               return this.setLocale((Locale)null);
             Locale l;
             try {
                 String s = DataTypeUtils.toString(locale, null);
                 if (StringUtils.isBlank(s)) {
                     return this.setLocale((Locale) null);
+                }
                 l = new Locale(s);
                 return this.setLocale(l);
             } catch (Exception ex) {
                 return this.setLocale((Locale) null);
+            }
             l = new Locale(s);
             return this.setLocale(l);
           } catch(Exception ex) {
               return this.setLocale((Locale)null);
+          }
+        }
         @Override
         public EditableFeatureAttributeDescriptor setRoundMode(int roundMode) {
           switch(roundMode) {
             case BigDecimal.ROUND_UP:
             case BigDecimal.ROUND_DOWN:
             case BigDecimal.ROUND_CEILING:
             case BigDecimal.ROUND_FLOOR:
             case BigDecimal.ROUND_HALF_UP:
             case BigDecimal.ROUND_HALF_DOWN:
             case BigDecimal.ROUND_HALF_EVEN:
             case BigDecimal.ROUND_UNNECESSARY:
               this.roundMode = roundMode;
               this.coerceContext = null;
               this.mathContext = null;
               break;
             default:
               throw new IllegalArgumentException("round mode '"+roundMode+"' not valid.");
+          }
           return this;
             switch (roundMode) {
                 case BigDecimal.ROUND_UP:
                 case BigDecimal.ROUND_DOWN:
                 case BigDecimal.ROUND_CEILING:
                 case BigDecimal.ROUND_FLOOR:
                 case BigDecimal.ROUND_HALF_UP:
                 case BigDecimal.ROUND_HALF_DOWN:
                 case BigDecimal.ROUND_HALF_EVEN:
                 case BigDecimal.ROUND_UNNECESSARY:
                     this.roundMode = roundMode;
                     this.coerceContext = null;
                     this.mathContext = null;
                     break;
                 default:
                     throw new IllegalArgumentException("round mode '" + roundMode + "' not valid.");
+            }
             return this;
+        }
         @Override
         public EditableFeatureAttributeDescriptor set(String name, Object value) {
             if( StringUtils.isBlank(name)) {
             if (StringUtils.isBlank(name)) {
                 throw new IllegalArgumentException("Name can't be empty");
+            }
             String ss;
             switch(name.trim().toLowerCase()) {
             String ss;
             switch (name.trim().toLowerCase()) {
                 case "isavoidcachingavailablevalues":
                 case "avoidcachingavailablevalues":
                 case "nocachingavailablevalues":
-...
                     this.setScale(DataTypeUtils.toInteger(value, 10));
                     break;
                 case "roundmode":
                   this.setRoundMode(DataTypeUtils.toInteger(value, BigDecimal.ROUND_UNNECESSARY));
                   break;
                     this.setRoundMode(DataTypeUtils.toInteger(value, BigDecimal.ROUND_UNNECESSARY));
                     break;
                 case "locale":
                   this.setLocale(DataTypeUtils.toString(value, null));
                   break;
                     this.setLocale(DataTypeUtils.toString(value, null));
                     break;
                 case "order":
                     this.setOrder(DataTypeUtils.toInteger(value, 0));
                     break;
-...
                 case "foreingkey.label":
                     this.getForeingKey().setLabelFormula(DataTypeUtils.toString(value, ""));
                     break;
                 case "fk_closed":
                 case "fk_closedlist":
                 case "fk.closedlist":
                 case "foreingkey_closedlist":
                 case "foreingkey.closedlist":
-...
                 case "type":
                 case "datatype":
                     ss = DataTypeUtils.toString(value, null);
                     if( !StringUtils.isBlank(ss) ) {
                     if (!StringUtils.isBlank(ss)) {
                         this.setDataType(ToolsLocator.getDataTypesManager().getType(ss));
+                    }
                     break;
                 case "defaultValue":
                     this.defaultValue = value;
                     break;
                 default:
                     throw new IllegalArgumentException("Name attribute '"+name+"' not valid.");
+            }
                     throw new IllegalArgumentException("Name attribute '" + name + "' not valid.");
+            }
             return this;
+        }
         private int toRelation(Object value) {
           if (value == null) {
             return DynField.RELATION_TYPE_NONE;
+          }
           Integer x = (Integer) DataTypeUtils.coerce(DataTypes.INT,value, null);
           if (x != null) {
             return x;
+          }
           try {
             String s = value.toString().toUpperCase();
             switch (s) {
               case "NONE":
               default:
             if (value == null) {
                 return DynField.RELATION_TYPE_NONE;
               case "IDENTITY":
                 return DynField.RELATION_TYPE_IDENTITY;
               case "COLLABORATION":
                 return DynField.RELATION_TYPE_COLLABORATION;
               case "COMPOSITION":
                 return DynField.RELATION_TYPE_COMPOSITION;
               case "AGGREGATE":
                 return DynField.RELATION_TYPE_AGGREGATE;
+            }
           } catch(Exception ex) {
             return DynField.RELATION_TYPE_NONE;
+          }
             Integer x = (Integer) DataTypeUtils.coerce(DataTypes.INT, value, null);
             if (x != null) {
                 return x;
+            }
             try {
                 String s = value.toString().toUpperCase();
                 switch (s) {
                     case "NONE":
                     default:
                         return DynField.RELATION_TYPE_NONE;
                     case "IDENTITY":
                         return DynField.RELATION_TYPE_IDENTITY;
                     case "COLLABORATION":
                         return DynField.RELATION_TYPE_COLLABORATION;
                     case "COMPOSITION":
                         return DynField.RELATION_TYPE_COMPOSITION;
                     case "AGGREGATE":
                         return DynField.RELATION_TYPE_AGGREGATE;
+                }
             } catch (Exception ex) {
                 return DynField.RELATION_TYPE_NONE;
+            }
+        }
       @Override
       public EditableFeatureAttributeDescriptor setDisplaySize(int size) {
         this.displaySize = size;
         return this;
+      }
         @Override
         public EditableFeatureAttributeDescriptor setDisplaySize(int size) {
             this.displaySize = size;
             return this;
+        }
         @Override
         public EditableFeatureAttributeDescriptor setAvailableValuesFilter(Expression filter) {
             super.setAvailableValuesFilter(filter);
             return this;
+        }
         private static class TheJsonSerializer implements JsonManager.JsonSerializer {
             public TheJsonSerializer() {
             public TheJsonSerializer() {
+            }
             @Override
-...
             @Override
             public JsonObjectBuilder toJsonBuilder(Object value) {
                 return ((SupportToJson)value).toJsonBuilder();
                 return ((SupportToJson) value).toJsonBuilder();
+            }
+        }
         @Override
         public EditableFeatureAttributeDescriptor setForeingkey(
                 boolean isForeingkey,
-...
                 String tableName,
                 String codeName,
                 String labelFormula
             ) {
             if( isForeingkey ) {
         ) {
             if (isForeingkey) {
                 EditableForeingKey fk = this.getForeingKey();
                 fk.setForeingKey(isForeingkey);
                 fk.setClosedList(isClosedList);
-...
                 fk.setLabelFormula(labelFormula);
             } else {
                 this.foreingKey = null;
+            }
+            }
             return this;
+        }
-...
         public static void selfRegister() {
             Json.registerSerializer(new TheJsonSerializer());
+        }
+    }

Also available in: Unified diff