Revision 46970

View differences:

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/impl/DALDefaultImplLibrary.java
130 130
        identityManager.registerAction(DataManager.WRITE_STORE_AUTHORIZATION);
131 131
        
132 132
        
133
        DefaultFeatureQuery.registerPersistent();
134
        DefaultFeatureQueryOrder.registerPersistent();
133
        DefaultFeatureQuery.selfRegister();
134
        DefaultFeatureQueryOrder.selfRegister();
135 135
        FeatureReferenceFactory.registerPersistent();
136 136
        DefaultFeatureStoreTransforms.registerPersistent();
137 137
        AbstractFeatureStoreTransform.registerPersistent();
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/DefaultFeatureQuery.java
24 24
package org.gvsig.fmap.dal.feature.impl;
25 25

  
26 26
import java.util.ArrayList;
27
import java.util.Arrays;
28
import java.util.Collection;
27 29
import java.util.HashMap;
28 30
import java.util.Iterator;
29 31
import java.util.List;
30 32
import java.util.Map;
31
import java.util.logging.Level;
33
import javax.json.JsonObject;
32 34
import org.apache.commons.lang3.ArrayUtils;
33 35
import org.apache.commons.lang3.StringUtils;
34 36
import org.gvsig.expressionevaluator.Expression;
......
56 58
import org.slf4j.Logger;
57 59
import org.slf4j.LoggerFactory;
58 60
import org.gvsig.fmap.dal.feature.FeatureExtraColumns;
61
import org.gvsig.fmap.dal.feature.FeatureRuleExpression;
62
import org.gvsig.json.Json;
63
import org.gvsig.json.JsonArrayBuilder;
64
import org.gvsig.json.JsonObjectBuilder;
65
import org.gvsig.json.SupportJson;
66
import org.gvsig.json.SupportToJson;
59 67
import org.gvsig.tools.packageutils.Version;
60 68
import org.gvsig.tools.packageutils.impl.DefaultVersion;
61 69

  
......
243 251
    }
244 252

  
245 253
    @Override
246
    public void setScale(double scale) {
254
    public final void setScale(double scale) {
247 255
        this.setQueryParameter(SCALE_PARAM_NAME, scale);
248 256
    }
249 257

  
......
258 266
    }
259 267

  
260 268
    @Override
261
    public void setFeatureType(FeatureType featureType) {
269
    public final void setFeatureType(FeatureType featureType) {
262 270
        this.featureTypeId = featureType.getId();
263 271
    }
264 272

  
......
283 291
    }
284 292

  
285 293
    @Override
286
    public void setAttributeNames(String[] attributeNames) {
294
    public final void setAttributeNames(String[] attributeNames) {
287 295
        this.attributeNames.clear();
288 296
        if (attributeNames != null){
289
            for (int i=0 ; i<attributeNames.length ; i++){
290
                this.attributeNames.add(attributeNames[i]);
291
            }
297
            this.attributeNames.addAll(Arrays.asList(attributeNames));
292 298
        }
293 299
    }
294 300

  
......
478 484
                return;
479 485
            }
480 486

  
481
            for (int i=0 ; i<fieldNames.length ; i++){
482
                addAttributeName(fieldNames[i]);
487
            for (String fieldName : fieldNames) {
488
                addAttributeName(fieldName);
483 489
            }
484 490
        }
485 491
    }
......
538 544
        }
539 545
        
540 546
        if (groupByColumns!=null) {
541
            clone.groupByColumns = new ArrayList<String>();
547
            clone.groupByColumns = new ArrayList<>();
542 548
            for (String value : groupByColumns) {
543 549
                clone.groupByColumns.add(value);
544 550
            }
......
548 554
                
549 555
                
550 556
        if (aggregateFunctions!=null) {
551
            clone.aggregateFunctions = new HashMap<String, String>();
557
            clone.aggregateFunctions = new HashMap<>();
552 558
            for (String key : aggregateFunctions.keySet()) {
553 559
                clone.aggregateFunctions.put(key, aggregateFunctions.get(key));
554 560
            }
......
655 661
        List<Expression> filterList = state.getList("filter");
656 662
        String stateFilter = "";
657 663
        DataManager dataManager = DALLocator.getDataManager();
658
        if (filterList.size() == 0) {
664
        if (filterList.isEmpty()) {
659 665
            this.filter = null;
660 666
        } else if (filterList.size() == 1) {
661 667
            Expression expression = filterList.get(0);
......
716 722
    
717 723
    }
718 724

  
725
    public static void selfRegister() {
726
        registerPersistent();
727
        Json.registerSerializer(DefaultFeatureQuery.class);            
728
    }
729
    
719 730
    /**
720 731
     * Register the class on PersistenceManager
721 732
     *
722 733
     */
723
    public static void registerPersistent() {
734
    private static void registerPersistent() {
724 735
        DynStruct definition =
725 736
            ToolsLocator.getPersistenceManager()
726 737
            .addDefinition(DefaultFeatureQuery.class,
......
806 817
    public void setConstantsAttributeNames(String[] constantsAttributeNames) {
807 818
        this.constantsAttributeNames.clear();
808 819
        if (constantsAttributeNames != null){
809
            for (int i=0 ; i<constantsAttributeNames.length ; i++){
810
                this.constantsAttributeNames.add(constantsAttributeNames[i]);
811
            }
820
            this.constantsAttributeNames.addAll(Arrays.asList(constantsAttributeNames));
812 821
        }
813 822
    }
814 823

  
......
1055 1064
    public void setUseSubquery(boolean useSubquery) {
1056 1065
        this.useSubquery = useSubquery;
1057 1066
    }
1067

  
1068
    @Override
1069
    public void fromJson(JsonObject json) {
1070
        DataManager dataManager = DALLocator.getDataManager();
1071

  
1072
        String s = json.getString("version",null);
1073
        Version version = s==null?null:Version.valueOf(s);
1074
        
1075
        this.queryParameters = Json.toMap(json, "queryParameters");
1076
        this.featureTypeId = json.getString("featureTypeId", null);
1077

  
1078
        this.attributeNames = new ArrayList<>();
1079
        Collection theAttributeNames = Json.toCollection(json,"attributeNames");
1080
        if( theAttributeNames!=null ) {
1081
            this.attributeNames.addAll(theAttributeNames);
1082
        }
1083
        
1084
        List<Expression> filterList = null;
1085
        Collection theFilter = Json.toCollection(json, "filter");
1086
        if( theFilter!=null ) {
1087
            filterList = new ArrayList<>(theFilter);
1088
        }
1089
        if (filterList==null || filterList.isEmpty()) {
1090
            this.filter = null;
1091
        } else if (filterList.size() == 1) {
1092
            Expression expression = filterList.get(0);
1093
            Evaluator evaluator;
1094
            try {
1095
                evaluator = dataManager.createFilter(expression);
1096
            } catch (InitializeException ex) {
1097
                LOGGER.warn("Can't create evaluator", ex);
1098
                evaluator = null;
1099
            }
1100
            this.filter = evaluator;
1101
        } else {
1102
            AndEvaluator andEvaluator = null;
1103
            for (Expression expression : filterList) {
1104
                Evaluator evaluator;
1105
                try {
1106
                    evaluator = dataManager.createFilter(expression);
1107

  
1108
                    if (andEvaluator == null) {
1109
                        andEvaluator = new AndEvaluator(evaluator);
1110
                    } else {
1111
                        andEvaluator.addEvaluator(evaluator);
1112
                    }
1113
                } catch (InitializeException ex) {
1114
                    LOGGER.warn("Can't create AndEvaluator", ex);//TODO evaluator a null
1115
                    break;
1116
                }
1117
                this.filter = evaluator;
1118

  
1119
            }
1120
        }
1121
        this.limit = json.getInt("limit");
1122
        if(version == null || version.compareTo(VERSION_2_6_0)<0){
1123
            if(this.limit == 0) {
1124
                this.clearLimit();
1125
            }
1126
        }
1127
        this.pageSize = json.getInt("pageSize");
1128
        this.useSubquery = json.getBoolean("useSubquery",true);
1129
        this.storeName = json.getString("storeName");
1130
        
1131
        
1132
        this.order = (FeatureQueryOrder) Json.toObject(json, "order");
1133
        
1134
        Collection<String> theGroupByColumns = Json.toCollection(json.getJsonArray("groupByColumns"));
1135
        if (theGroupByColumns!=null) {
1136
            this.groupByColumns = new ArrayList<>(theGroupByColumns);
1137
        } else {
1138
            this.groupByColumns = null;
1139
        }
1140
        
1141
        
1142
        Map asMapAggregateFunctions = Json.toMap(json,"aggregateFunctions");
1143
        if (asMapAggregateFunctions!=null) {
1144
            this.aggregateFunctions = new HashMap<>(asMapAggregateFunctions);
1145
        } else {
1146
            this.aggregateFunctions = null;
1147
        }
1148
        this.extraColumns = (FeatureExtraColumns) Json.toObject(json,"extraColumn");
1149
    }
1150

  
1151
    @Override
1152
    public JsonObjectBuilder toJsonBuilder() {
1153
        JsonObjectBuilder state = Json.createObjectBuilder();
1154
        state.add("version", VERSION_2_6_0.toString());
1155
        state.add("queryParameters", this.queryParameters);
1156
        state.add("featureTypeId", this.featureTypeId);
1157
        state.add("attributeNames", this.attributeNames);
1158
        
1159
        JsonArrayBuilder filterList = Json.createArrayBuilder();
1160
        if (this.filter instanceof DefaultFeatureExpressionEvaluator) {
1161
            DefaultFeatureExpressionEvaluator filterExpression = (DefaultFeatureExpressionEvaluator) this.filter;
1162
           filterList.add(filterExpression.toExpression());
1163
        } else if (this.filter instanceof AndEvaluator) {
1164
            AndEvaluator filterAnd = (AndEvaluator) this.filter;
1165
            List<Evaluator> evaluators = filterAnd.getEvaluators();
1166
            for (Evaluator evaluator : evaluators) {
1167
                if (evaluator instanceof DefaultFeatureExpressionEvaluator) {
1168
                    DefaultFeatureExpressionEvaluator expressionEvaluator = (DefaultFeatureExpressionEvaluator) evaluator;
1169
                    filterList.add(expressionEvaluator.toExpression());
1170
                } else {
1171
                    filterList = Json.createArrayBuilder();
1172
                    LOGGER.warn(StringUtils.join("Filters in this FeatureQuery will not persist:", this.toString()));
1173
                    break;
1174
                }
1175
            }
1176
        } else {
1177
            filterList = Json.createArrayBuilder();
1178
            if( this.filter!=null ) {
1179
                LOGGER.warn(StringUtils.join("Filters in this FeatureQuery will not persist:", this.toString()));
1180
            }
1181
        }
1182
        
1183
        state.add("filter", filterList);
1184
        state.add("limit", this.limit);
1185
        state.add("pageSize", this.pageSize);
1186
        state.add("useSubquery", this.useSubquery);
1187
        
1188
        state.add("order", (SupportJson) this.order); 
1189
        state.add("groupByColumns", this.groupByColumns); 
1190
        state.add("aggregateFunctions", this.aggregateFunctions);
1191
        state.add("extraColumn", (SupportToJson) this.extraColumns); 
1192
	state.add("storeName", this.storeName);
1193
        
1194
        return state;
1195
    }
1058 1196
    
1059 1197
}
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/DefaultFeatureQueryOrder.java
28 28
import java.util.Iterator;
29 29
import java.util.List;
30 30
import java.util.NoSuchElementException;
31
import javax.json.JsonArray;
32
import javax.json.JsonObject;
33
import javax.json.JsonValue;
31 34
import org.apache.commons.lang3.StringUtils;
32 35
import org.gvsig.expressionevaluator.Expression;
33 36
import org.gvsig.expressionevaluator.ExpressionEvaluator;
......
35 38
import org.gvsig.fmap.dal.feature.Feature;
36 39
import org.gvsig.fmap.dal.feature.FeatureQueryOrder;
37 40
import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureExpressionEvaluator;
41
import org.gvsig.json.Json;
42
import org.gvsig.json.JsonObjectBuilder;
38 43
import org.gvsig.tools.ToolsLocator;
39 44
import org.gvsig.tools.dynobject.DynStruct;
40 45
import org.gvsig.tools.evaluator.Evaluator;
......
130 135
            this.ascending = ascending;
131 136
        }
132 137

  
138
        @Override
139
        public void fromJson(JsonObject json) {
140
            this.attributeName = json.getString("attributeName", null);
141
            this.ascending = json.getBoolean("ascending", true);
142
            this.evaluator = (Evaluator) Json.toObject(json, "evaluator");
143
        }
144

  
145
        @Override
146
        public JsonObjectBuilder toJsonBuilder() {
147
            JsonObjectBuilder state = Json.createObjectBuilder();
148
            state.add("attributeName", this.attributeName);
149
            state.add("ascending", this.ascending);
150
            if(evaluator instanceof ExpressionEvaluator){
151
                state.add("evaluator", evaluator);
152
            } else {
153
                state.addNull("evaluator");
154
            }
155
            return state;
156
        }
157

  
133 158
    }
134 159

  
135 160
    private List<FeatureQueryOrderMember> members = new ArrayList();
......
353 378
        return aCopy;
354 379
    }
355 380

  
381
    public static void selfRegister() {        
382
        registerPersistent();
383
        Json.registerSerializer(DefaultFeatureQueryOrder.class);                    
384
        Json.registerSerializer(FeatureQueryOrderMemberImpl.class);                    
385
    }
386
    
356 387
    /**
357 388
     * Register the class on PersistenceManager
358 389
     *
359 390
     */
360
    public static void registerPersistent() {
391
    private static void registerPersistent() {
361 392
        DynStruct definitionMember
362 393
                = ToolsLocator.getPersistenceManager()
363 394
                        .addDefinition(FeatureQueryOrderMemberImpl.class,
......
469 500

  
470 501
    }
471 502

  
503
    @Override
504
    public void fromJson(JsonObject json) {
505
        JsonArray stateMembers = json.getJsonArray("members");
506
        this.members = new ArrayList<>();
507
        for (JsonValue stateMember : stateMembers) {
508
            this.members.add((FeatureQueryOrderMember) Json.toObject(stateMember));
509
        }
510
    }
511

  
512
    @Override
513
    public JsonObjectBuilder toJsonBuilder() {
514
        JsonObjectBuilder state = Json.createObjectBuilder();
515
        state.add("members", members);
516
        return state;
517
    }
518

  
472 519
}
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.api/src/main/java/org/gvsig/fmap/dal/feature/FeatureQuery.java
33 33
import org.gvsig.expressionevaluator.MutableSymbolTable;
34 34
import org.gvsig.expressionevaluator.SymbolTable;
35 35
import org.gvsig.fmap.dal.DataQuery;
36
import org.gvsig.json.SupportJson;
36 37
import org.gvsig.tools.evaluator.Evaluator;
37 38
import org.gvsig.tools.lang.Cloneable;
38 39

  
......
66 67
 *
67 68
 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team
68 69
 */
69
public interface FeatureQuery extends DataQuery, Cloneable {
70
public interface FeatureQuery extends DataQuery, Cloneable, SupportJson {
70 71

  
71 72
    public static final int NO_LIMIT = -1;
72 73
    
trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.api/src/main/java/org/gvsig/fmap/dal/feature/FeatureQueryOrder.java
25 25
import java.util.Iterator;
26 26
import org.gvsig.expressionevaluator.Expression;
27 27
import org.gvsig.fmap.dal.feature.FeatureQueryOrder.FeatureQueryOrderMember;
28
import org.gvsig.json.SupportJson;
29
import org.gvsig.json.SupportToJson;
28 30
import org.gvsig.tools.evaluator.Evaluator;
29 31
import org.gvsig.tools.lang.Cloneable;
30 32
import org.gvsig.tools.persistence.Persistent;
......
33 35
 *
34 36
 * @author fdiaz
35 37
 */
36
public interface FeatureQueryOrder extends Cloneable, Iterable<FeatureQueryOrderMember>, Persistent {
38
public interface FeatureQueryOrder extends Cloneable, Iterable<FeatureQueryOrderMember>, Persistent, SupportJson {
37 39

  
38
    public interface FeatureQueryOrderMember extends Persistent, Cloneable {
40
    public interface FeatureQueryOrderMember extends Persistent, Cloneable, SupportJson {
39 41

  
40 42
        FeatureQueryOrderMember clone() throws CloneNotSupportedException;
41 43

  

Also available in: Unified diff