Application: gvSIG desktop

import java.lang.reflect.Constructor;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.sldsupport.exception.SLDReadException;

import org.gvsig.sldsupport.exception.SLDWriteException;

import org.gvsig.sldsupport.io.SLDLegendReader;

import org.gvsig.sldsupport.io.SLDLegendWriter;

import org.gvsig.sldsupport.io.SLDSymbolReader;

import org.gvsig.sldsupport.io.SLDSymbolWriter;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamReader;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;

	private Map<Class<? extends ISymbol>, Set<SLDSymbolReader>> symToReaders =

	new HashMap<Class<? extends ISymbol>, Set<SLDSymbolReader>>();

	private Map<Class<? extends ILegend>, Set<SLDLegendReader>> legToReaders =

	new HashMap<Class<? extends ILegend>, Set<SLDLegendReader>>();

	// ================

	private Map<Class<? extends ISymbol>, Set<SLDSymbolWriter>> symToWriters =

	new HashMap<Class<? extends ISymbol>, Set<SLDSymbolWriter>>();

	private Map<Class<? extends ILegend>, Set<SLDLegendWriter>> legToWriters =

	new HashMap<Class<? extends ILegend>, Set<SLDLegendWriter>>();

	/*

	public IMarkerSymbol readMarkerSymbol(IXmlStreamReader reader)

			throws SLDReadException {

		// TODO Auto-generated method stub

		return null;

	}

	public ILineSymbol readLineSymbol(IXmlStreamReader reader)

			throws SLDReadException {

		// TODO Auto-generated method stub

		return null;

	}

	public IFillSymbol readFillSymbol(IXmlStreamReader reader)

			throws SLDReadException {

		// TODO Auto-generated method stub

		return null;

	}

	*/

	public ISymbol readSymbol(IXmlStreamReader reader, String version)

			throws SLDReadException {

		throw new SLDReadException(new Exception("Not implemented."));

	}

	public ILegend readLegend(IXmlStreamReader reader, String version)

			throws SLDReadException {

		throw new SLDReadException(new Exception("Not implemented."));

	}

	public void writeLegend(ILegend leg, IXmlStreamWriter writer, String version)

			throws SLDWriteException {

		if (leg == null) {

			throw new SLDWriteException(new Exception("Legend is NULL"));

		}

		Set<SLDLegendWriter> set = legToWriters.get(leg.getClass());

		if (set == null) {

			throw new SLDWriteException(new Exception(

					"Unsupported legend: '" + leg.getClass().getName() + "'"));

		}

		Iterator<SLDLegendWriter> iter = set.iterator();

		List<String> vv = null;

		SLDLegendWriter item = null;

		while (iter.hasNext()) {

			item = iter.next();

			vv = item.getSupportedVersions();

			if (vv.contains(version)) {

				item.write(leg, writer, version);

				return;

			}

		}

		throw new SLDWriteException(new Exception(

				"Legend is supported: '" + leg.getClass().getName()

						+ "' but not in version '" + version + "'"));

	}

	public void writeSymbol(ISymbol sym, IXmlStreamWriter writer, String version)

			throws SLDWriteException {

		if (sym == null) {

			throw new SLDWriteException(new Exception("Symbol is NULL"));

		}

		Set<SLDSymbolWriter> set = symToWriters.get(sym.getClass());

		if (set == null) {

			throw new SLDWriteException(new Exception(

					"Unsupported symbol: '" + sym.getClass().getName() + "'"));

		}

		Iterator<SLDSymbolWriter> iter = set.iterator();

		List<String> vv = null;

		SLDSymbolWriter item = null;

		while (iter.hasNext()) {

			item = iter.next();

			vv = item.getSupportedVersions();

			if (vv.contains(version)) {

				item.write(sym, writer, version);

				return;

			}

		}

		throw new SLDWriteException(new Exception(

				"Symbol is supported: '" + sym.getClass().getName()

						+ "' but not in version '" + version + "'"));

	}

	// =========================================

	// =========================================

	public void registerSymbolReader(SLDSymbolReader reader) {

		Iterator<Class<? extends ISymbol>> iter =

				reader.getSupportedSymbols().iterator();

		Class<? extends ISymbol> clazz = null;

		Set<SLDSymbolReader> set = null;

		while (iter.hasNext()) {

			clazz = iter.next();

			set = this.symToReaders.get(clazz);

			if (set == null) {

				set = new HashSet<SLDSymbolReader>();

				set.add(reader);

				this.symToReaders.put(clazz, set);

			} else {

				set.add(reader);

			}

		}

	}

	public void registerSymbolWriter(SLDSymbolWriter writer) {

		Iterator<Class<? extends ISymbol>> iter =

				writer.getSupportedSymbols().iterator();

		Class<? extends ISymbol> clazz = null;

		Set<SLDSymbolWriter> set = null;

		while (iter.hasNext()) {

			clazz = iter.next();

			set = this.symToWriters.get(clazz);

			if (set == null) {

				set = new HashSet<SLDSymbolWriter>();

				set.add(writer);

				this.symToWriters.put(clazz, set);

			} else {

				set.add(writer);

			}

		}

	}

	public void registerLegendReader(SLDLegendReader reader) {

		Iterator<Class<? extends ILegend>> iter =

				reader.getSupportedLegends().iterator();

		Class<? extends ILegend> clazz = null;

		Set<SLDLegendReader> set = null;

		while (iter.hasNext()) {

			clazz = iter.next();

			set = this.legToReaders.get(clazz);

			if (set == null) {

				set = new HashSet<SLDLegendReader>();

				set.add(reader);

				this.legToReaders.put(clazz, set);

			} else {

				set.add(reader);

			}

		}

	}

	public void registerLegendWriter(SLDLegendWriter writer) {

		Iterator<Class<? extends ILegend>> iter =

				writer.getSupportedLegends().iterator();

		Class<? extends ILegend> clazz = null;

		Set<SLDLegendWriter> set = null;

		while (iter.hasNext()) {

			clazz = iter.next();

			set = this.legToWriters.get(clazz);

			if (set == null) {

				set = new HashSet<SLDLegendWriter>();

				set.add(writer);

				this.legToWriters.put(clazz, set);

			} else {

				set.add(writer);

			}

		}

	}

	// =============================

//	private SLDSymbolWriter getSymbolWriterForClass(

//			Class<? extends ISymbol> clazz, String v) throws Exception {

//		

//		Set<SLDSymbolWriter> list = symToWriters.get(clazz);

//		

//		Class<? extends ISymbol> item = null;

//		SLDSymbolWriter resp = null;

//		while (iter.hasNext()) {

//			item = iter.next();

//			if (item == clazz) {

//				resp = symToWriter.get(item);

//				return resp;

//			}

//		}

//		return null;

//	}

//	

//	private SLDLegendWriter getLegendWriterForClass(Class<? extends ILegend> clazz)

//	throws Exception {

//		

//		Iterator<Class<? extends ILegend>> iter = legToWriter.keySet().iterator();

//		Class<? extends ILegend> item = null;

//		SLDLegendWriter resp = null;

//		while (iter.hasNext()) {

//			item = iter.next();

//			if (item == clazz) {

//				resp = legToWriter.get(item);

//				return resp;

//			}

//		}

//		return null;

//	}

	/*

	private Object instantiate(Class clazz) throws Exception {

		Constructor con = null;

		con = clazz.getConstructor((Class<?>[]) null);

		return con.newInstance((Object[]) null);

	}

	*/