OpenLayers OpenLayers

Changeset 7651

Show
Ignore:
Timestamp:
07/31/08 19:34:19 (4 months ago)
Author:
tschaub
Message:

Adding a filter format for version 1.0.0 filter encoding. The sld parser extends itself to use readers and writers from the filter parser. r=me (closes #1605)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/openlayers/lib/OpenLayers.js

    r7650 r7651  
    204204            "OpenLayers/Format/SLD/v1.js", 
    205205            "OpenLayers/Format/SLD/v1_0_0.js", 
     206            "OpenLayers/Format/SLD/v1.js", 
     207            "OpenLayers/Format/Filter.js", 
     208            "OpenLayers/Format/Filter/v1.js", 
     209            "OpenLayers/Format/Filter/v1_0_0.js", 
    206210            "OpenLayers/Format/Text.js", 
    207211            "OpenLayers/Format/JSON.js", 

  • trunk/openlayers/lib/OpenLayers/Format/SLD.js

    r6895 r7651  
    1010 * @requires OpenLayers/Filter/Logical.js 
    1111 * @requires OpenLayers/Filter/Comparison.js 
     12 * @requires OpenLayers/Filter/Spatial.js 
    1213 */ 
    1314 

  • trunk/openlayers/lib/OpenLayers/Format/SLD/v1.js

    r7634 r7651  
    6767     */ 
    6868    initialize: function(options) { 
     69        // extend with ogc:Filter readers and writers 
     70        this.readers["ogc"] = OpenLayers.Format.Filter.v1.prototype.readers["ogc"]; 
     71        this.writers["ogc"] = OpenLayers.Format.Filter.v1.prototype.writers["ogc"]; 
     72        // extend with custom filter methods that may get changed 
     73        this.readOgcExpression = OpenLayers.Format.Filter.v1.prototype.readOgcExpression; 
     74        this.getFilterType = OpenLayers.Format.Filter.v1.prototype.getFilterType; 
     75        this.filterMap = OpenLayers.Format.Filter.v1.prototype.filterMap; 
    6976        OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); 
    7077    }, 
    …… 
    274281                graphic.graphicFormat = this.getChildValue(node); 
    275282            } 
    276         }, 
    277         "ogc": { 
    278             "Filter": function(node, rule) { 
    279                 // Filters correspond to subclasses of OpenLayers.Filter. 
    280                 // Since they contain information we don't persist, we 
    281                 // create a temporary object and then pass on the filter 
    282                 // (ogc:Filter) to the parent rule (sld:Rule). 
    283                 var obj = { 
    284                     fids: [], 
    285                     filters: [] 
    286                 }; 
    287                 this.readChildNodes(node, obj); 
    288                 if(obj.fids.length > 0) { 
    289                     rule.filter = new OpenLayers.Filter.FeatureId({ 
    290                         fids: obj.fids 
    291                     }); 
    292                 } else if(obj.filters.length > 0) { 
    293                     rule.filter = obj.filters[0]; 
    294                 } 
    295             }, 
    296             "FeatureId": function(node, obj) { 
    297                 var fid = node.getAttribute("fid"); 
    298                 if(fid) { 
    299                     obj.fids.push(fid); 
    300                 } 
    301             }, 
    302             "And": function(node, obj) { 
    303                 var filter = new OpenLayers.Filter.Logical({ 
    304                     type: OpenLayers.Filter.Logical.AND 
    305                 }); 
    306                 this.readChildNodes(node, filter); 
    307                 obj.filters.push(filter); 
    308             }, 
    309             "Or": function(node, obj) { 
    310                 var filter = new OpenLayers.Filter.Logical({ 
    311                     type: OpenLayers.Filter.Logical.OR 
    312                 }); 
    313                 this.readChildNodes(node, filter); 
    314                 obj.filters.push(filter); 
    315             }, 
    316             "Not": function(node, obj) { 
    317                 var filter = new OpenLayers.Filter.Logical({ 
    318                     type: OpenLayers.Filter.Logical.NOT 
    319                 }); 
    320                 this.readChildNodes(node, filter); 
    321                 obj.filters.push(filter); 
    322             }, 
    323             "PropertyIsEqualTo": function(node, obj) { 
    324                 var filter = new OpenLayers.Filter.Comparison({ 
    325                     type: OpenLayers.Filter.Comparison.EQUAL_TO 
    326                 }); 
    327                 this.readChildNodes(node, filter); 
    328                 obj.filters.push(filter); 
    329             }, 
    330             "PropertyIsNotEqualTo": function(node, obj) { 
    331                 var filter = new OpenLayers.Filter.Comparison({ 
    332                     type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO 
    333                 }); 
    334                 this.readChildNodes(node, filter); 
    335                 obj.filters.push(filter); 
    336             }, 
    337             "PropertyIsLessThan": function(node, obj) { 
    338                 var filter = new OpenLayers.Filter.Comparison({ 
    339                     type: OpenLayers.Filter.Comparison.LESS_THAN 
    340                 }); 
    341                 this.readChildNodes(node, filter); 
    342                 obj.filters.push(filter); 
    343             }, 
    344             "PropertyIsGreaterThan": function(node, obj) { 
    345                 var filter = new OpenLayers.Filter.Comparison({ 
    346                     type: OpenLayers.Filter.Comparison.GREATER_THAN 
    347                 }); 
    348                 this.readChildNodes(node, filter); 
    349                 obj.filters.push(filter); 
    350             }, 
    351             "PropertyIsLessThanOrEqualTo": function(node, obj) { 
    352                 var filter = new OpenLayers.Filter.Comparison({ 
    353                     type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO 
    354                 }); 
    355                 this.readChildNodes(node, filter); 
    356                 obj.filters.push(filter); 
    357             }, 
    358             "PropertyIsGreaterThanOrEqualTo": function(node, obj) { 
    359                 var filter = new OpenLayers.Filter.Comparison({ 
    360                     type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO 
    361                 }); 
    362                 this.readChildNodes(node, filter); 
    363                 obj.filters.push(filter); 
    364             }, 
    365             "PropertyIsBetween": function(node, obj) { 
    366                 var filter = new OpenLayers.Filter.Comparison({ 
    367                     type: OpenLayers.Filter.Comparison.BETWEEN 
    368                 }); 
    369                 this.readChildNodes(node, filter); 
    370                 obj.filters.push(filter); 
    371             }, 
    372             "PropertyIsLike": function(node, obj) { 
    373                 var filter = new OpenLayers.Filter.Comparison({ 
    374                     type: OpenLayers.Filter.Comparison.LIKE 
    375                 }); 
    376                 this.readChildNodes(node, filter); 
    377                 var wildCard = node.getAttribute("wildCard"); 
    378                 var singleChar = node.getAttribute("singleChar"); 
    379                 var esc = node.getAttribute("escape"); 
    380                 filter.value2regex(wildCard, singleChar, esc); 
    381                 obj.filters.push(filter); 
    382             }, 
    383             "Literal": function(node, obj) { 
    384                 obj.value = this.getChildValue(node); 
    385             }, 
    386             "PropertyName": function(node, filter) { 
    387                 filter.property = this.getChildValue(node); 
    388             }, 
    389             "LowerBoundary": function(node, filter) { 
    390                 filter.lowerBoundary = this.readOgcExpression(node); 
    391             }, 
    392             "UpperBoundary": function(node, filter) { 
    393                 filter.upperBoundary = this.readOgcExpression(node); 
    394             } 
    395         } 
    396     }, 
    397      
    398     /** 
    399      * Method: readOgcExpression 
    400      * Limited support for OGC expressions. 
    401      * 
    402      * Parameters: 
    403      * node - {DOMElement} A DOM element that contains an ogc:expression. 
    404      * 
    405      * Returns: 
    406      * {String} A value to be used in a symbolizer. 
    407      */ 
    408     readOgcExpression: function(node) { 
    409         var obj = {}; 
    410         this.readChildNodes(node, obj); 
    411         var value = obj.value; 
    412         if(!value) { 
    413             value = this.getChildValue(node); 
    414         } 
    415         return value; 
     283        } 
    416284    }, 
    417285     
    …… 
    898766                }); 
    899767            } 
    900         }, 
    901         "ogc": { 
    902             "Filter": function(filter) { 
    903                 var node = this.createElementNSPlus("ogc:Filter"); 
    904                 var sub = filter.CLASS_NAME.split(".").pop(); 
    905                 if(sub == "FeatureId") { 
    906                     for(var i=0, len=filter.fids.length; i<len; ++i) { 
    907                         this.writeNode(node, "FeatureId", filter.fids[i]); 
    908                     } 
    909                 } else { 
    910                     this.writeNode(node, this.getFilterType(filter), filter); 
    911                 } 
    912                 return node; 
    913             }, 
    914             "FeatureId": function(fid) { 
    915                 return this.createElementNSPlus("ogc:FeatureId", { 
    916                     attributes: {fid: fid} 
    917                 }); 
    918             }, 
    919             "And": function(filter) { 
    920                 var node = this.createElementNSPlus("ogc:And"); 
    921                 var childFilter; 
    922                 for(var i=0, len=filter.filters.length; i<len; ++i) { 
    923                     childFilter = filter.filters[i]; 
    924                     this.writeNode( 
    925                         node, this.getFilterType(childFilter), childFilter 
    926                     ); 
    927                 } 
    928                 return node; 
    929             }, 
    930             "Or": function(filter) { 
    931                 var node = this.createElementNSPlus("ogc:Or"); 
    932                 var childFilter; 
    933                 for(var i=0, len=filter.filters.length; i<len; ++i) { 
    934                     childFilter = filter.filters[i]; 
    935                     this.writeNode( 
    936                         node, this.getFilterType(childFilter), childFilter 
    937                     ); 
    938                 } 
    939                 return node; 
    940             }, 
    941             "Not": function(filter) { 
    942                 var node = this.createElementNSPlus("ogc:Not"); 
    943                 var childFilter = filter.filters[0]; 
    944                 this.writeNode( 
    945                     node, this.getFilterType(childFilter), childFilter 
    946                 ); 
    947                 return node; 
    948             }, 
    949             "PropertyIsEqualTo": function(filter) { 
    950                 var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); 
    951                 // no ogc:expression handling for now 
    952                 this.writeNode(node, "PropertyName", filter); 
    953                 this.writeNode(node, "Literal", filter.value); 
    954                 return node; 
    955             }, 
    956             "PropertyIsNotEqualTo": function(filter) { 
    957                 var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); 
    958                 // no ogc:expression handling for now 
    959                 this.writeNode(node, "PropertyName", filter); 
    960                 this.writeNode(node, "Literal", filter.value); 
    961                 return node; 
    962             }, 
    963             "PropertyIsLessThan": function(filter) { 
    964                 var node = this.createElementNSPlus("ogc:PropertyIsLessThan"); 
    965                 // no ogc:expression handling for now 
    966                 this.writeNode(node, "PropertyName", filter); 
    967                 this.writeNode(node, "Literal", filter.value);                 
    968                 return node; 
    969             }, 
    970             "PropertyIsGreaterThan": function(filter) { 
    971                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan"); 
    972                 // no ogc:expression handling for now 
    973                 this.writeNode(node, "PropertyName", filter); 
    974                 this.writeNode(node, "Literal", filter.value); 
    975                 return node; 
    976             }, 
    977             "PropertyIsLessThanOrEqualTo": function(filter) { 
    978                 var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo"); 
    979                 // no ogc:expression handling for now 
    980                 this.writeNode(node, "PropertyName", filter); 
    981                 this.writeNode(node, "Literal", filter.value); 
    982                 return node; 
    983             }, 
    984             "PropertyIsGreaterThanOrEqualTo": function(filter) { 
    985                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo"); 
    986                 // no ogc:expression handling for now 
    987                 this.writeNode(node, "PropertyName", filter); 
    988                 this.writeNode(node, "Literal", filter.value); 
    989                 return node; 
    990             }, 
    991             "PropertyIsBetween": function(filter) { 
    992                 var node = this.createElementNSPlus("ogc:PropertyIsBetween"); 
    993                 // no ogc:expression handling for now 
    994                 this.writeNode(node, "PropertyName", filter); 
    995                 this.writeNode(node, "LowerBoundary", filter); 
    996                 this.writeNode(node, "UpperBoundary", filter); 
    997                 return node; 
    998             }, 
    999             "PropertyIsLike": function(filter) { 
    1000                 var node = this.createElementNSPlus("ogc:PropertyIsLike", { 
    1001                     attributes: { 
    1002                         wildCard: "*", singleChar: ".", escape: "!" 
    1003                     } 
    1004                 }); 
    1005                 // no ogc:expression handling for now 
    1006                 this.writeNode(node, "PropertyName", filter); 
    1007                 // convert regex string to ogc string 
    1008                 this.writeNode(node, "Literal", filter.regex2value()); 
    1009                 return node; 
    1010             }, 
    1011             "PropertyName": function(filter) { 
    1012                 // no ogc:expression handling for now 
    1013                 return this.createElementNSPlus("ogc:PropertyName", { 
    1014                     value: filter.property 
    1015                 }); 
    1016             }, 
    1017             "Literal": function(value) { 
    1018                 // no ogc:expression handling for now 
    1019                 return this.createElementNSPlus("ogc:Literal", { 
    1020                     value: value 
    1021                 }); 
    1022             }, 
    1023             "LowerBoundary": function(filter) { 
    1024                 // no ogc:expression handling for now 
    1025                 var node = this.createElementNSPlus("ogc:LowerBoundary"); 
    1026                 this.writeNode(node, "Literal", filter.lowerBoundary); 
    1027                 return node; 
    1028             }, 
    1029             "UpperBoundary": function(filter) { 
    1030                 // no ogc:expression handling for now 
    1031                 var node = this.createElementNSPlus("ogc:UpperBoundary"); 
    1032                 this.writeNode(node, "Literal", filter.upperBoundary); 
    1033                 return node; 
    1034             } 
    1035         } 
    1036     }, 
    1037      
    1038     /** 
    1039      * Method: getFilterType 
    1040      */ 
    1041     getFilterType: function(filter) { 
    1042         var filterType = this.filterMap[filter.type]; 
    1043         if(!filterType) { 
    1044             throw "SLD writing not supported for rule type: " + filter.type; 
    1045         } 
    1046         return filterType; 
    1047     }, 
    1048      
    1049     /** 
    1050      * Property: filterMap 
    1051      * {Object} Contains a member for each filter type.  Values are node names 
    1052      *     for corresponding OGC Filter child elements. 
    1053      */ 
    1054     filterMap: { 
    1055         "&&": "And", 
    1056         "||": "Or", 
    1057         "!": "Not", 
    1058         "==": "PropertyIsEqualTo", 
    1059         "!=": "PropertyIsNotEqualTo", 
    1060         "<": "PropertyIsLessThan", 
    1061         ">": "PropertyIsGreaterThan", 
    1062         "<=": "PropertyIsLessThanOrEqualTo", 
    1063         ">=": "PropertyIsGreaterThanOrEqualTo", 
    1064         "..": "PropertyIsBetween", 
    1065         "~": "PropertyIsLike" 
    1066     }, 
    1067      
    1068  
     768        } 
     769    }, 
     770     
    1069771    /** 
    1070772     * Methods below this point are of general use for versioned XML parsers. 

  • trunk/openlayers/tests/list-tests.html

    r7650 r7651  
    4949    <li>Format/SLD.html</li> 
    5050    <li>Format/SLD/v1_0_0.html</li> 
     51    <li>Format/Filter.html</li> 
     52    <li>Format/Filter/v1_0_0.html</li> 
    5153    <li>Format/WKT.html</li> 
    5254    <li>Format/WMC.html</li>