Application: gvSIG desktop

package org.gvsig.sldsupport.impl;

import java.io.File;

import java.io.OutputStream;

import java.util.Collection;

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.layers.vectorial.VectorLayer;

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

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

import org.gvsig.sldsupport.SLDSupportManager;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParser;

public class DefaultSLDSupportManager implements SLDSupportManager {

        private static Logger logger = LoggerFactory.getLogger(DefaultSLDSupportManager.class);

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

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

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

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

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

        public DefaultSLDSupportManager() {

        }

        public ILegend readLegend(File f, VectorLayer vlayer)

                        throws SLDReadException {

                ILegend resp = null;

                Collection<Set<SLDLegendReader>> all_readers = legToReaders.values();

                Iterator<Set<SLDLegendReader>> iter_a = all_readers.iterator();

                Set<SLDLegendReader> item_a = null;

                Iterator<SLDLegendReader> iter_b = null;

                SLDLegendReader item_b = null;

                while (iter_a.hasNext()) {

                        item_a = iter_a.next();

                        iter_b = item_a.iterator();

                        while (iter_b.hasNext()) {

                                item_b = iter_b.next();

                                try {

                                        resp = item_b.readLegend(f, vlayer);

                                } catch (SLDReadException exc) {

                                        logger.info("While reading SLD file.", exc);

                                        // This reader did not work

                                } catch (Exception exc) {

                                        logger.info("While reading SLD file.", exc);

                                }

                                if (resp != null) {

                                        return resp;

                                }

                        }

                }

                throw new SLDReadException(new Exception(

                                "Unable to read legend from file: " + f.getAbsolutePath()));

        }

        public void writeLegend(

                        ILegend leg,

                        String layer_name,

                        OutputStream out,

                        String version)

                        throws SLDWriteException {

                if (leg == null) {

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

                }

                Set<SLDLegendWriter> set = getLegendWritersFor(leg);

                if (set == null || set.size() == 0) {

                        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.writeLegend(leg, layer_name, out, version);

                                return;

                        }

                }

                throw new SLDWriteException(new Exception(

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

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

        }

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

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

        public void registerLegendReader(SLDLegendReader reader) {

                List<Class<? extends ILegend>> list = reader.getSupportedLegends();

                if (list == null || list.size() == 0) {

                        return;

                }

                Iterator<Class<? extends ILegend>> iter = list.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) {

                List<Class<? extends ILegend>> list = writer.getSupportedLegends();

                if (list == null || list.size() == 0) {

                        return;

                }

                Iterator<Class<? extends ILegend>> iter = list.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 Set<SLDLegendWriter> getLegendWritersFor(ILegend leg) {

                Set<SLDLegendWriter> resp = new HashSet<SLDLegendWriter>();

                if (leg == null) {

                        return resp;

                }

                Class<? extends ILegend> target = leg.getClass();

                Class<? extends ILegend> kitem = null;

                Iterator<Class<? extends ILegend>> kiter = legToWriters.keySet().iterator();

                while (kiter.hasNext()) {

                        kitem = kiter.next();

                        if (kitem.isAssignableFrom(target)) {

                                /*

                                 * kitem is same or superclass/superinterface of target

                                 */

                                resp.addAll(legToWriters.get(kitem));

                        }

                }

                return resp;

        }

}