svn-gvsig-desktop / branches / v02_desarrollo / libraries / sld / temp / org.gvsig.sldsupport.lib.impl / src / main / java / org / gvsig / sldsupport / impl / DefaultSLDSupportManager.java @ 40799
History | View | Annotate | Download (18.4 KB)
1 |
package org.gvsig.sldsupport.impl; |
---|---|
2 |
|
3 |
import java.io.File; |
4 |
import java.io.FileInputStream; |
5 |
import java.io.FileOutputStream; |
6 |
import java.io.IOException; |
7 |
import java.io.InputStream; |
8 |
import java.io.OutputStream; |
9 |
import java.util.ArrayList; |
10 |
import java.util.HashMap; |
11 |
import java.util.HashSet; |
12 |
import java.util.Iterator; |
13 |
import java.util.List; |
14 |
import java.util.Map; |
15 |
import java.util.Set; |
16 |
|
17 |
import org.gvsig.sldsupport.SLDSupportManager; |
18 |
import org.gvsig.sldsupport.exception.InvalidSLDObjectException; |
19 |
import org.gvsig.sldsupport.exception.SLDException; |
20 |
import org.gvsig.sldsupport.exception.SLDReadException; |
21 |
import org.gvsig.sldsupport.exception.SLDWriteException; |
22 |
import org.gvsig.sldsupport.exception.UnsupportedSLDVersionException; |
23 |
import org.gvsig.sldsupport.impl.util.SLDUtils; |
24 |
import org.gvsig.sldsupport.reader.SLDReader; |
25 |
import org.gvsig.sldsupport.reader.SLDReaderFactory; |
26 |
import org.gvsig.sldsupport.sld.SLDObject; |
27 |
import org.gvsig.sldsupport.writer.SLDWriter; |
28 |
import org.gvsig.sldsupport.writer.SLDWriterFactory; |
29 |
import org.slf4j.Logger; |
30 |
import org.slf4j.LoggerFactory; |
31 |
import org.xmlpull.v1.XmlPullParserException; |
32 |
|
33 |
public class DefaultSLDSupportManager implements SLDSupportManager { |
34 |
|
35 |
private static Logger logger = LoggerFactory.getLogger( |
36 |
DefaultSLDSupportManager.class); |
37 |
|
38 |
private Map<String, Set<SLDReaderFactory>> versionToReaders = |
39 |
new HashMap<String, Set<SLDReaderFactory>>(); |
40 |
private Map<String, Set<SLDWriterFactory>> versionToWriters = |
41 |
new HashMap<String, Set<SLDWriterFactory>>(); |
42 |
|
43 |
public void registerReader(SLDReaderFactory fact) { |
44 |
|
45 |
String v = fact.getVersion();
|
46 |
Set<SLDReaderFactory> set = versionToReaders.get(v);
|
47 |
if (set == null) { |
48 |
set = new HashSet<SLDReaderFactory>(); |
49 |
set.add(fact); |
50 |
versionToReaders.put(v, set); |
51 |
} else {
|
52 |
set.add(fact); |
53 |
} |
54 |
} |
55 |
|
56 |
public void registerWriter(SLDWriterFactory fact) { |
57 |
|
58 |
String v = fact.getVersion();
|
59 |
Set<SLDWriterFactory> set = versionToWriters.get(v);
|
60 |
if (set == null) { |
61 |
set = new HashSet<SLDWriterFactory>(); |
62 |
set.add(fact); |
63 |
versionToWriters.put(v, set); |
64 |
} else {
|
65 |
set.add(fact); |
66 |
} |
67 |
|
68 |
} |
69 |
|
70 |
public List<SLDWriter> createWriters(String version) |
71 |
throws UnsupportedSLDVersionException {
|
72 |
|
73 |
Set<SLDWriterFactory> set = versionToWriters.get(version);
|
74 |
if (set == null || set.size() == 0) { |
75 |
throw new UnsupportedSLDVersionException(version); |
76 |
} |
77 |
|
78 |
List<SLDWriter> resp = new ArrayList<SLDWriter>(); |
79 |
Iterator<SLDWriterFactory> iter = set.iterator();
|
80 |
SLDWriterFactory fact = null;
|
81 |
while (iter.hasNext()) {
|
82 |
fact = iter.next(); |
83 |
try {
|
84 |
resp.add(fact.create()); |
85 |
} catch (Exception exc) { |
86 |
logger.info("Error while creating writer (ignored)", exc);
|
87 |
} |
88 |
} |
89 |
return resp;
|
90 |
} |
91 |
|
92 |
public List<SLDReader> createReaders(String version) |
93 |
throws UnsupportedSLDVersionException {
|
94 |
|
95 |
Set<SLDReaderFactory> set = versionToReaders.get(version);
|
96 |
if (set == null || set.size() == 0) { |
97 |
throw new UnsupportedSLDVersionException(version); |
98 |
} |
99 |
|
100 |
List<SLDReader> resp = new ArrayList<SLDReader>(); |
101 |
Iterator<SLDReaderFactory> iter = set.iterator();
|
102 |
SLDReaderFactory fact = null;
|
103 |
while (iter.hasNext()) {
|
104 |
fact = iter.next(); |
105 |
try {
|
106 |
resp.add(fact.create()); |
107 |
} catch (Exception exc) { |
108 |
logger.info("Error while creating reader (ignored)", exc);
|
109 |
} |
110 |
} |
111 |
return resp;
|
112 |
} |
113 |
|
114 |
public void write(SLDObject obj, String version, File outfile) |
115 |
throws IOException, SLDException { |
116 |
|
117 |
if (obj == null) { |
118 |
throw new IOException("Input SLDObject is null"); |
119 |
} |
120 |
|
121 |
Set<SLDWriterFactory> wset = this.versionToWriters.get(version); |
122 |
if (wset == null || wset.size() == 0) { |
123 |
throw new UnsupportedSLDVersionException(version); |
124 |
} |
125 |
|
126 |
OutputStream outstream = null; |
127 |
Iterator<SLDWriterFactory> witer = wset.iterator();
|
128 |
SLDWriterFactory fact_item = null;
|
129 |
SLDWriter witem = null;
|
130 |
/*
|
131 |
* Trying to write without forcing...
|
132 |
*/
|
133 |
while (witer.hasNext()) {
|
134 |
fact_item = witer.next(); |
135 |
witem = fact_item.create(); |
136 |
outstream = new FileOutputStream(outfile); |
137 |
try {
|
138 |
witem.write(obj, outstream); |
139 |
// It was possible to write without forcing
|
140 |
return;
|
141 |
} catch (Exception exc) { |
142 |
logger.info("One of the writers was unable to write object: "
|
143 |
+ obj.getClass().getSimpleName()); |
144 |
// Go on...
|
145 |
} finally {
|
146 |
try { outstream.close(); } catch (Exception exc) { } |
147 |
} |
148 |
} |
149 |
/*
|
150 |
* It was not possible to write without forcing.
|
151 |
* Now we'll try to write with forceWrite
|
152 |
*/
|
153 |
witer = wset.iterator(); |
154 |
while (witer.hasNext()) {
|
155 |
fact_item = witer.next(); |
156 |
witem = fact_item.create(); |
157 |
outstream = new FileOutputStream(outfile); |
158 |
try {
|
159 |
witem.forceWrite(obj, outstream); |
160 |
// It was possible to write without forcing
|
161 |
return;
|
162 |
} catch (Exception exc) { |
163 |
logger.info("One of the writers was unable to force-write object: "
|
164 |
+ obj.getClass().getSimpleName()); |
165 |
// Go on...
|
166 |
} finally {
|
167 |
try { outstream.close(); } catch (Exception exc) { } |
168 |
} |
169 |
} |
170 |
/*
|
171 |
* It was not possible to write with forceWrite
|
172 |
*/
|
173 |
throw new SLDWriteException( |
174 |
"Unable to write with available writers ("
|
175 |
+ obj.getClass().getSimpleName() + ")");
|
176 |
} |
177 |
|
178 |
|
179 |
public SLDObject read(File infile) |
180 |
throws SLDException, IOException { |
181 |
|
182 |
if (infile == null || !infile.exists()) { |
183 |
throw new IOException("Null or non-existing file: " |
184 |
+ ((infile == null) ? "Null" : infile.getAbsolutePath())); |
185 |
} |
186 |
|
187 |
|
188 |
String ve = null; |
189 |
try {
|
190 |
ve = SLDUtils.detectVersion(infile); |
191 |
} catch (XmlPullParserException e) {
|
192 |
} |
193 |
|
194 |
System.out.println("Version = " + ve); |
195 |
|
196 |
InputStream instream = null; |
197 |
Iterator<String> iter = versionToReaders.keySet().iterator(); |
198 |
String vitem = null; |
199 |
Set<SLDReaderFactory> sitem = null; |
200 |
Iterator<SLDReaderFactory> siter = null; |
201 |
SLDReaderFactory fact_item = null;
|
202 |
SLDReader ritem = null;
|
203 |
SLDObject resp = null;
|
204 |
boolean found = false; |
205 |
while (iter.hasNext()) {
|
206 |
vitem = iter.next(); |
207 |
sitem = versionToReaders.get(vitem); |
208 |
siter = sitem.iterator(); |
209 |
while (siter.hasNext()) {
|
210 |
|
211 |
found = true; // Used to decide message in exception |
212 |
fact_item = siter.next(); |
213 |
ritem = fact_item.create(); |
214 |
instream = new FileInputStream(infile); |
215 |
try {
|
216 |
resp = ritem.read(instream); |
217 |
} catch (Exception exc) { |
218 |
logger.info("One of the readers was unable to parse file: " + infile.getAbsolutePath(), exc);
|
219 |
} |
220 |
try { instream.close(); } catch (Exception exc) { } |
221 |
if (resp != null) { |
222 |
return resp;
|
223 |
} |
224 |
} |
225 |
} |
226 |
if (found) {
|
227 |
throw new SLDReadException( "No available SLD reader was able to parse file: " |
228 |
+ infile.getAbsolutePath()); |
229 |
} else {
|
230 |
throw new SLDReadException("No SLD readers found."); |
231 |
} |
232 |
|
233 |
} |
234 |
|
235 |
// public static String VERSION = "1.0.0";
|
236 |
//
|
237 |
// private static Logger logger = LoggerFactory.getLogger(DefaultSLDSupportManager.class);
|
238 |
//
|
239 |
// private Map<Class<? extends ILegend>, Set<SLDLegendReader>> legToReaders =
|
240 |
// new HashMap<Class<? extends ILegend>, Set<SLDLegendReader>>();
|
241 |
// // ================
|
242 |
// private Map<Class<? extends ILegend>, Set<SLDLegendWriter>> legToWriters =
|
243 |
// new HashMap<Class<? extends ILegend>, Set<SLDLegendWriter>>();
|
244 |
//
|
245 |
// private SLDProtocolHandler handler = new SLDProtocolHandler1_0_0();
|
246 |
//
|
247 |
// public DefaultSLDSupportManager() {
|
248 |
//
|
249 |
// }
|
250 |
//
|
251 |
// public void writeLegend(
|
252 |
// ILegend leg, String layer_name, File out_file,
|
253 |
// String version) throws IOException, SLDWriteException {
|
254 |
//
|
255 |
// if (leg == null) {
|
256 |
// throw new SLDWriteException(new Exception("Legend is NULL"));
|
257 |
// }
|
258 |
// Set<SLDLegendWriter> set = getLegendWritersFor(leg);
|
259 |
//
|
260 |
// if (set == null || set.size() == 0) {
|
261 |
// throw new SLDWriteException(new Exception(
|
262 |
// "Unsupported legend: '" + leg.getClass().getName() + "'"));
|
263 |
// }
|
264 |
//
|
265 |
// Iterator<SLDLegendWriter> iter = set.iterator();
|
266 |
// List<String> vv = null;
|
267 |
// SLDLegendWriter item = null;
|
268 |
// while (iter.hasNext()) {
|
269 |
// item = iter.next();
|
270 |
// vv = item.getSupportedVersions();
|
271 |
// if (vv.contains(version)) {
|
272 |
// ISLDLayer sld_layer = item.getSLDLayer(leg, layer_name, version);
|
273 |
// SLDUtils.writeSLDLayer(sld_layer, out_file, version);
|
274 |
// return;
|
275 |
// }
|
276 |
// }
|
277 |
// throw new SLDWriteException(new Exception(
|
278 |
// "Legend is supported: '" + leg.getClass().getName()
|
279 |
// + "' but not in version '" + version + "'"));
|
280 |
// }
|
281 |
//
|
282 |
// // =========================================
|
283 |
// // =========================================
|
284 |
//
|
285 |
// public void registerLegendReader(SLDLegendReader reader) {
|
286 |
//
|
287 |
// List<Class<? extends ILegend>> list = reader.getSupportedLegends();
|
288 |
// if (list == null || list.size() == 0) {
|
289 |
// return;
|
290 |
// }
|
291 |
// Iterator<Class<? extends ILegend>> iter = list.iterator();
|
292 |
//
|
293 |
// Class<? extends ILegend> clazz = null;
|
294 |
// Set<SLDLegendReader> set = null;
|
295 |
// while (iter.hasNext()) {
|
296 |
// clazz = iter.next();
|
297 |
// set = this.legToReaders.get(clazz);
|
298 |
// if (set == null) {
|
299 |
// set = new HashSet<SLDLegendReader>();
|
300 |
// set.add(reader);
|
301 |
// this.legToReaders.put(clazz, set);
|
302 |
// } else {
|
303 |
// set.add(reader);
|
304 |
// }
|
305 |
// }
|
306 |
// }
|
307 |
//
|
308 |
// public void registerLegendWriter(SLDLegendWriter writer) {
|
309 |
//
|
310 |
// List<Class<? extends ILegend>> list = writer.getSupportedLegends();
|
311 |
// if (list == null || list.size() == 0) {
|
312 |
// return;
|
313 |
// }
|
314 |
// Iterator<Class<? extends ILegend>> iter = list.iterator();
|
315 |
//
|
316 |
// Class<? extends ILegend> clazz = null;
|
317 |
// Set<SLDLegendWriter> set = null;
|
318 |
// while (iter.hasNext()) {
|
319 |
// clazz = iter.next();
|
320 |
// set = this.legToWriters.get(clazz);
|
321 |
// if (set == null) {
|
322 |
// set = new HashSet<SLDLegendWriter>();
|
323 |
// set.add(writer);
|
324 |
// this.legToWriters.put(clazz, set);
|
325 |
// } else {
|
326 |
// set.add(writer);
|
327 |
// }
|
328 |
// }
|
329 |
// }
|
330 |
//
|
331 |
//
|
332 |
// // =============================
|
333 |
//
|
334 |
// private Set<SLDLegendWriter> getLegendWritersFor(ILegend leg) {
|
335 |
//
|
336 |
// Set<SLDLegendWriter> resp = new HashSet<SLDLegendWriter>();
|
337 |
// if (leg == null) {
|
338 |
// return resp;
|
339 |
// }
|
340 |
// Class<? extends ILegend> target = leg.getClass();
|
341 |
// Class<? extends ILegend> kitem = null;
|
342 |
// Iterator<Class<? extends ILegend>> kiter = legToWriters.keySet().iterator();
|
343 |
// while (kiter.hasNext()) {
|
344 |
// kitem = kiter.next();
|
345 |
// if (kitem.isAssignableFrom(target)) {
|
346 |
// /*
|
347 |
// * kitem is same or superclass/superinterface of target
|
348 |
// */
|
349 |
// resp.addAll(legToWriters.get(kitem));
|
350 |
// }
|
351 |
// }
|
352 |
// return resp;
|
353 |
// }
|
354 |
//
|
355 |
// public List<ISLDLayer> getSLDLayers(File f, String v) throws SLDReadException {
|
356 |
//
|
357 |
// try {
|
358 |
// handler.parse(f);
|
359 |
// } catch (Exception e) {
|
360 |
// throw new SLDReadException(e);
|
361 |
// }
|
362 |
//
|
363 |
// return handler.getLayers();
|
364 |
// }
|
365 |
//
|
366 |
// public ILegend getLegend(ISLDLayer sld_layer, VectorLayer vlayer, String v)
|
367 |
// throws SLDReadException {
|
368 |
//
|
369 |
// ILegend resp = null;
|
370 |
// Collection<Set<SLDLegendReader>> all_readers = legToReaders.values();
|
371 |
//
|
372 |
// Iterator<Set<SLDLegendReader>> iter_a = all_readers.iterator();
|
373 |
// Set<SLDLegendReader> item_a = null;
|
374 |
// Iterator<SLDLegendReader> iter_b = null;
|
375 |
// SLDLegendReader item_b = null;
|
376 |
// while (iter_a.hasNext()) {
|
377 |
// item_a = iter_a.next();
|
378 |
// iter_b = item_a.iterator();
|
379 |
// while (iter_b.hasNext()) {
|
380 |
// item_b = iter_b.next();
|
381 |
// try {
|
382 |
// resp = item_b.getLegend(sld_layer, vlayer, v);
|
383 |
// } catch (SLDReadException exc) {
|
384 |
// logger.info("While reading SLD file.", exc);
|
385 |
// // This reader did not work
|
386 |
// } catch (Exception exc) {
|
387 |
// logger.info("While reading SLD file.", exc);
|
388 |
// }
|
389 |
// if (resp != null) {
|
390 |
// return resp;
|
391 |
// }
|
392 |
// }
|
393 |
// }
|
394 |
// throw new SLDReadException(new Exception(
|
395 |
// "Unable to read legend from SLD layer: " + sld_layer.getName()));
|
396 |
// }
|
397 |
//
|
398 |
// // ============================================================
|
399 |
// // ============================================================
|
400 |
// // ============================================================
|
401 |
//
|
402 |
//
|
403 |
// public SLDExtent createSLDExtent(String version)
|
404 |
// throws UnsupportedSLDVersionException{
|
405 |
//
|
406 |
// if (version.compareTo(VERSION) == 0) {
|
407 |
// return new SLDExtent1_0_0();
|
408 |
// } else {
|
409 |
// throw new UnsupportedSLDVersionException(version);
|
410 |
// }
|
411 |
// }
|
412 |
//
|
413 |
// public SLDFeatureTypeConstraint createSLDFeatureTypeConstraint(
|
414 |
// String version) throws UnsupportedSLDVersionException{
|
415 |
//
|
416 |
// if (version.compareTo(VERSION) == 0) {
|
417 |
// return new SLDFeatureTypeConstraint1_0_0();
|
418 |
// } else {
|
419 |
// throw new UnsupportedSLDVersionException(version);
|
420 |
// }
|
421 |
// }
|
422 |
//
|
423 |
// public SLDLayerFeatureConstraints createSLDLayerFeatureConstraints(
|
424 |
// String version) throws UnsupportedSLDVersionException{
|
425 |
//
|
426 |
// if (version.compareTo(VERSION) == 0) {
|
427 |
// return new SLDLayerFeatureConstraints1_0_0();
|
428 |
// } else {
|
429 |
// throw new UnsupportedSLDVersionException(version);
|
430 |
// }
|
431 |
// }
|
432 |
//
|
433 |
// public SLDExternalGraphic createSLDExternalGraphic(String version)
|
434 |
// throws UnsupportedSLDVersionException{
|
435 |
//
|
436 |
// if (version.compareTo(VERSION) == 0) {
|
437 |
// return new SLDExternalGraphic1_0_0();
|
438 |
// } else {
|
439 |
// throw new UnsupportedSLDVersionException(version);
|
440 |
// }
|
441 |
// }
|
442 |
//
|
443 |
// public SLDFill createSLDFill(String version) throws UnsupportedSLDVersionException{
|
444 |
//
|
445 |
// if (version.compareTo(VERSION) == 0) {
|
446 |
// return new SLDFill1_0_0();
|
447 |
// } else {
|
448 |
// throw new UnsupportedSLDVersionException(version);
|
449 |
// }
|
450 |
// }
|
451 |
//
|
452 |
// public SLDGraphic createSLDGraphic(String version)
|
453 |
// throws UnsupportedSLDVersionException{
|
454 |
// if (version.compareTo(VERSION) == 0) {
|
455 |
// return new SLDGraphic1_0_0();
|
456 |
// } else {
|
457 |
// throw new UnsupportedSLDVersionException(version);
|
458 |
// }
|
459 |
// }
|
460 |
//
|
461 |
// public SLDLegendGraphic createSLDLegendGraphic(String version)
|
462 |
// throws UnsupportedSLDVersionException{
|
463 |
//
|
464 |
// if (version.compareTo(VERSION) == 0) {
|
465 |
// return new SLDLegendGraphic1_0_0();
|
466 |
// } else {
|
467 |
// throw new UnsupportedSLDVersionException(version);
|
468 |
// }
|
469 |
// }
|
470 |
//
|
471 |
// public SLDMark createSLDMark(String version)
|
472 |
// throws UnsupportedSLDVersionException{
|
473 |
//
|
474 |
// if (version.compareTo(VERSION) == 0) {
|
475 |
// return new SLDMark1_0_0();
|
476 |
// } else {
|
477 |
// throw new UnsupportedSLDVersionException(version);
|
478 |
// }
|
479 |
// }
|
480 |
//
|
481 |
// public SLDStroke createSLDStroke(String version)
|
482 |
// throws UnsupportedSLDVersionException{
|
483 |
//
|
484 |
// if (version.compareTo(VERSION) == 0) {
|
485 |
// return new SLDStroke1_0_0();
|
486 |
// } else {
|
487 |
// throw new UnsupportedSLDVersionException(version);
|
488 |
// }
|
489 |
// }
|
490 |
//
|
491 |
// public SLDNamedLayer createSLDNamedLayer(String version)
|
492 |
// throws UnsupportedSLDVersionException{
|
493 |
//
|
494 |
// if (version.compareTo(VERSION) == 0) {
|
495 |
// return new SLDNamedLayer1_0_0();
|
496 |
// } else {
|
497 |
// throw new UnsupportedSLDVersionException(version);
|
498 |
// }
|
499 |
// }
|
500 |
//
|
501 |
// public SLDUserLayer createSLDUserLayer(String version)
|
502 |
// throws UnsupportedSLDVersionException{
|
503 |
//
|
504 |
// if (version.compareTo(VERSION) == 0) {
|
505 |
// return new SLDUserLayer1_0_0();
|
506 |
// } else {
|
507 |
// throw new UnsupportedSLDVersionException(version);
|
508 |
// }
|
509 |
// }
|
510 |
//
|
511 |
// public SLDRule createSLDRule(String version)
|
512 |
// throws UnsupportedSLDVersionException{
|
513 |
//
|
514 |
// if (version.compareTo(VERSION) == 0) {
|
515 |
// return new SLDRule1_0_0();
|
516 |
// } else {
|
517 |
// throw new UnsupportedSLDVersionException(version);
|
518 |
// }
|
519 |
// }
|
520 |
//
|
521 |
// public SLDFeatureTypeStyle createSLDFeatureTypeStyle(String version)
|
522 |
// throws UnsupportedSLDVersionException{
|
523 |
//
|
524 |
// if (version.compareTo(VERSION) == 0) {
|
525 |
// return new SLDFeatureTypeStyle1_0_0();
|
526 |
// } else {
|
527 |
// throw new UnsupportedSLDVersionException(version);
|
528 |
// }
|
529 |
// }
|
530 |
//
|
531 |
// public SLDNamedStyle createSLDNamedStyle(String version)
|
532 |
// throws UnsupportedSLDVersionException {
|
533 |
//
|
534 |
// if (version.compareTo(VERSION) == 0) {
|
535 |
// return new SLDNamedStyle1_0_0();
|
536 |
// } else {
|
537 |
// throw new UnsupportedSLDVersionException(version);
|
538 |
// }
|
539 |
// }
|
540 |
//
|
541 |
// public SLDUserStyle createSLDUserStyle(String version)
|
542 |
// throws UnsupportedSLDVersionException {
|
543 |
//
|
544 |
// if (version.compareTo(VERSION) == 0) {
|
545 |
// return new SLDUserStyle1_0_0();
|
546 |
// } else {
|
547 |
// throw new UnsupportedSLDVersionException(version);
|
548 |
// }
|
549 |
// }
|
550 |
//
|
551 |
// public SLDPointSymbolizer createSLDPointSymbolizer(String version)
|
552 |
// throws UnsupportedSLDVersionException{
|
553 |
//
|
554 |
// if (version.compareTo(VERSION) == 0) {
|
555 |
// return new SLDPointSymbolizer1_0_0();
|
556 |
// } else {
|
557 |
// throw new UnsupportedSLDVersionException(version);
|
558 |
// }
|
559 |
// }
|
560 |
//
|
561 |
// public SLDMultiPointSymbolizer createSLDMultiPointSymbolizer(String version)
|
562 |
// throws UnsupportedSLDVersionException{
|
563 |
//
|
564 |
// if (version.compareTo(VERSION) == 0) {
|
565 |
// return new SLDMultiPointSymbolizer1_0_0();
|
566 |
// } else {
|
567 |
// throw new UnsupportedSLDVersionException(version);
|
568 |
// }
|
569 |
// }
|
570 |
//
|
571 |
// public SLDLineSymbolizer createSLDLineSymbolizer(String version)
|
572 |
// throws UnsupportedSLDVersionException {
|
573 |
//
|
574 |
// if (version.compareTo(VERSION) == 0) {
|
575 |
// return new SLDLineSymbolizer1_0_0();
|
576 |
// } else {
|
577 |
// throw new UnsupportedSLDVersionException(version);
|
578 |
// }
|
579 |
// }
|
580 |
//
|
581 |
// public SLDMultiLineSymbolizer createSLDMultiLineSymbolizer(String version)
|
582 |
// throws UnsupportedSLDVersionException {
|
583 |
//
|
584 |
// if (version.compareTo(VERSION) == 0) {
|
585 |
// return new SLDMultiLineSymbolizer1_0_0();
|
586 |
// } else {
|
587 |
// throw new UnsupportedSLDVersionException(version);
|
588 |
// }
|
589 |
// }
|
590 |
//
|
591 |
// public SLDPolygonSymbolizer createSLDPolygonSymbolizer(String version)
|
592 |
// throws UnsupportedSLDVersionException{
|
593 |
//
|
594 |
// if (version.compareTo(VERSION) == 0) {
|
595 |
// return new SLDPolygonSymbolizer1_0_0();
|
596 |
// } else {
|
597 |
// throw new UnsupportedSLDVersionException(version);
|
598 |
// }
|
599 |
// }
|
600 |
//
|
601 |
// public SLDMultiPolygonSymbolizer createSLDMultiPolygonSymbolizer(
|
602 |
// String version) throws UnsupportedSLDVersionException{
|
603 |
//
|
604 |
// if (version.compareTo(VERSION) == 0) {
|
605 |
// return new SLDMultiPolygonSymbolizer1_0_0();
|
606 |
// } else {
|
607 |
// throw new UnsupportedSLDVersionException(version);
|
608 |
// }
|
609 |
// }
|
610 |
//
|
611 |
// public SLDMultiShapeSymbolizer createSLDMultiShapeSymbolizer(String version)
|
612 |
// throws UnsupportedSLDVersionException {
|
613 |
//
|
614 |
// if (version.compareTo(VERSION) == 0) {
|
615 |
// return new SLDMultiShapeSymbolizer1_0_0();
|
616 |
// } else {
|
617 |
// throw new UnsupportedSLDVersionException(version);
|
618 |
// }
|
619 |
// }
|
620 |
//
|
621 |
// public List<String> getSupportedVersions() {
|
622 |
//
|
623 |
// List<String> resp = new ArrayList<String>();
|
624 |
// resp.add(VERSION);
|
625 |
// return resp;
|
626 |
// }
|
627 |
|
628 |
|
629 |
|
630 |
|
631 |
|
632 |
|
633 |
} |