ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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)

Browse Source 
git-svn-id: http://svn.openlayers.org/trunk/openlayers@7651 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
Tim Schaub
2008-07-31 23:34:19 +00:00
parent 360d7412f0
commit d4a62c630a
9 changed files with 844 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/OpenLayers/Format/SLD/v1.js
+7 -305
View File
@@ -66,6 +66,13 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
* this instance.
*/
initialize: function(options) {
// extend with ogc:Filter readers and writers
this.readers["ogc"] = OpenLayers.Format.Filter.v1.prototype.readers["ogc"];
this.writers["ogc"] = OpenLayers.Format.Filter.v1.prototype.writers["ogc"];
// extend with custom filter methods that may get changed
this.readOgcExpression = OpenLayers.Format.Filter.v1.prototype.readOgcExpression;
this.getFilterType = OpenLayers.Format.Filter.v1.prototype.getFilterType;
this.filterMap = OpenLayers.Format.Filter.v1.prototype.filterMap;
OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
},
@@ -273,148 +280,9 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
"Format": function(node, graphic) {
graphic.graphicFormat = this.getChildValue(node);
}
},
"ogc": {
"Filter": function(node, rule) {
// Filters correspond to subclasses of OpenLayers.Filter.
// Since they contain information we don't persist, we
// create a temporary object and then pass on the filter
// (ogc:Filter) to the parent rule (sld:Rule).
var obj = {
fids: [],
filters: []
};
this.readChildNodes(node, obj);
if(obj.fids.length > 0) {
rule.filter = new OpenLayers.Filter.FeatureId({
fids: obj.fids
});
} else if(obj.filters.length > 0) {
rule.filter = obj.filters[0];
}
},
"FeatureId": function(node, obj) {
var fid = node.getAttribute("fid");
if(fid) {
obj.fids.push(fid);
}
},
"And": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.AND
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Or": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.OR
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Not": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.NOT
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.EQUAL_TO
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsNotEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsBetween": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.BETWEEN
});
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLike": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LIKE
});
this.readChildNodes(node, filter);
var wildCard = node.getAttribute("wildCard");
var singleChar = node.getAttribute("singleChar");
var esc = node.getAttribute("escape");
filter.value2regex(wildCard, singleChar, esc);
obj.filters.push(filter);
},
"Literal": function(node, obj) {
obj.value = this.getChildValue(node);
},
"PropertyName": function(node, filter) {
filter.property = this.getChildValue(node);
},
"LowerBoundary": function(node, filter) {
filter.lowerBoundary = this.readOgcExpression(node);
},
"UpperBoundary": function(node, filter) {
filter.upperBoundary = this.readOgcExpression(node);
}
}
},
/**
* Method: readOgcExpression
* Limited support for OGC expressions.
*
* Parameters:
* node - {DOMElement} A DOM element that contains an ogc:expression.
*
* Returns:
* {String} A value to be used in a symbolizer.
*/
readOgcExpression: function(node) {
var obj = {};
this.readChildNodes(node, obj);
var value = obj.value;
if(!value) {
value = this.getChildValue(node);
}
return value;
},
/**
* Property: cssMap
* {Object} Object mapping supported css property names to OpenLayers
@@ -897,175 +765,9 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
value: format
});
}
},
"ogc": {
"Filter": function(filter) {
var node = this.createElementNSPlus("ogc:Filter");
var sub = filter.CLASS_NAME.split(".").pop();
if(sub == "FeatureId") {
for(var i=0, len=filter.fids.length; i<len; ++i) {
this.writeNode(node, "FeatureId", filter.fids[i]);
}
} else {
this.writeNode(node, this.getFilterType(filter), filter);
}
return node;
},
"FeatureId": function(fid) {
return this.createElementNSPlus("ogc:FeatureId", {
attributes: {fid: fid}
});
},
"And": function(filter) {
var node = this.createElementNSPlus("ogc:And");
var childFilter;
for(var i=0, len=filter.filters.length; i<len; ++i) {
childFilter = filter.filters[i];
this.writeNode(
node, this.getFilterType(childFilter), childFilter
);
}
return node;
},
"Or": function(filter) {
var node = this.createElementNSPlus("ogc:Or");
var childFilter;
for(var i=0, len=filter.filters.length; i<len; ++i) {
childFilter = filter.filters[i];
this.writeNode(
node, this.getFilterType(childFilter), childFilter
);
}
return node;
},
"Not": function(filter) {
var node = this.createElementNSPlus("ogc:Not");
var childFilter = filter.filters[0];
this.writeNode(
node, this.getFilterType(childFilter), childFilter
);
return node;
},
"PropertyIsEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsNotEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsLessThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThan");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsGreaterThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsLessThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsGreaterThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsBetween": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsBetween");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "LowerBoundary", filter);
this.writeNode(node, "UpperBoundary", filter);
return node;
},
"PropertyIsLike": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLike", {
attributes: {
wildCard: "*", singleChar: ".", escape: "!"
}
});
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", filter);
// convert regex string to ogc string
this.writeNode(node, "Literal", filter.regex2value());
return node;
},
"PropertyName": function(filter) {
// no ogc:expression handling for now
return this.createElementNSPlus("ogc:PropertyName", {
value: filter.property
});
},
"Literal": function(value) {
// no ogc:expression handling for now
return this.createElementNSPlus("ogc:Literal", {
value: value
});
},
"LowerBoundary": function(filter) {
// no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:LowerBoundary");
this.writeNode(node, "Literal", filter.lowerBoundary);
return node;
},
"UpperBoundary": function(filter) {
// no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:UpperBoundary");
this.writeNode(node, "Literal", filter.upperBoundary);
return node;
}
}
},
/**
* Method: getFilterType
*/
getFilterType: function(filter) {
var filterType = this.filterMap[filter.type];
if(!filterType) {
throw "SLD writing not supported for rule type: " + filter.type;
}
return filterType;
},
/**
* Property: filterMap
* {Object} Contains a member for each filter type. Values are node names
* for corresponding OGC Filter child elements.
*/
filterMap: {
"&&": "And",
"||": "Or",
"!": "Not",
"==": "PropertyIsEqualTo",
"!=": "PropertyIsNotEqualTo",
"<": "PropertyIsLessThan",
">": "PropertyIsGreaterThan",
"<=": "PropertyIsLessThanOrEqualTo",
">=": "PropertyIsGreaterThanOrEqualTo",
"..": "PropertyIsBetween",
"~": "PropertyIsLike"
},
/**
* Methods below this point are of general use for versioned XML parsers.
* These are candidates for an abstract class.