| gvSIG desktop 1

/*

 * Created on 07-sep-2007

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

 *

 * $Id: 

 * $Log: 

 */

package org.gvsig.topology;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.fmap.MapContext;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.vividsolutions.jts.geom.Envelope;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.topology.topologyrules.MustBeLargerThanClusterTolerance;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

public class Topology extends FLayers implements ITopologyErrorContainer, ITopologyStatus {

        /**

         * Unique identifier which will be autoupdating for all those new errors

         * added to the ITopologyErrorContainer

         */

        private int errorFid = 0;

        /**

         * cluster tolerance of the topology

         */

        private double clusterTolerance;

        /**

         * validation status of the topology

         */

        private byte status = ITopologyStatus.NON_VALIDATED;

        /**

         *If during validation process a topoly

         *exceeds this parameters, validation will be stopped.

         *

         */

        private int maxNumberOfErrors = -1;

        /**

         * topology rules of the topology

         */

        private List rules;

        /**

         * Each layer of a topology must have a cluster tolerance

         * rule

         */

        private List clusterToleranceRules;

        /**

         * Regions of the topology to be validated

         */

        private List dirtyZones;

        //TODO Change List for a persistent datastore

        //as TopologyError extends DefaultFeature, we could use a driver and a writer

        private List topologyErrors;

        /**

         * Default constructor for a topology as a FLayers

         * @param fmap

         * @param parent

         */

        public Topology(MapContext fmap, FLayers parent) {

                super(fmap, parent);

        }

        /**

         * Constructor

         * @param clusterTolerance

         * @param maxNumberOfErrors

         */

        public Topology(double clusterTolerance, int maxNumberOfErrors){

                super(null, null);

                this.clusterTolerance = clusterTolerance;

                this.maxNumberOfErrors = maxNumberOfErrors;

                rules = new  ArrayList();

                clusterToleranceRules = new ArrayList();

                dirtyZones = new ArrayList();

        }

        /**

         * Changes the cluster tolerance of the topology

         * @param clusterTolerance

         */

        public void setClusterTolerance(double clusterTolerance){

                this.clusterTolerance = clusterTolerance;

        }

        public double getClusterTolerance() {

                return clusterTolerance;

        }

        /**

         *Adds a new topology rule to the topology.

         */

        public void addRule(AbstractTopologyRule rule) {

                rules.add(rule);

        }

        /*

         * Overwrited implementations of FLayers methods

         * */

        public void addLayer(FLayer layer) {

                if(! (layer instanceof FLyrVect))

                        throw new WrongLyrForTopologyException("Intentando a?adir capa no vectorial a una topologia");

                super.addLayer(layer);

                status = ITopologyStatus.NON_VALIDATED;

                MustBeLargerThanClusterTolerance rule = new MustBeLargerThanClusterTolerance();

                try {

                        addDirtyZone(layer.getFullExtent());

                } catch (ExpansionFileReadException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public void addLayer(int pos, FLayer layer) {

                if(! (layer instanceof FLyrVect))

                        throw new WrongLyrForTopologyException("Intentando a?adir capa no vectorial a una topologia");

                super.addLayer(pos, layer);

                status = ITopologyStatus.NON_VALIDATED;

                try {

                        addDirtyZone(layer.getFullExtent());

                } catch (ExpansionFileReadException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        /**

         *Adds a layer to the topology. If the topology has been validated, changes

         *topology status to NON-VALIDATED and adds a dirty zone equals to

         *the layer extent.

         */

        public void addLayer(FLyrVect layer, int xyRank, int zRank) {

//                

//                MustBeLargerThanClusterTolerance rule = 

//                        new MustBeLargerThanClusterTolerance();

        }

        public void setStatus(byte status) {

                this.status = status; 

        }

        public byte getStatus() {

                return status;

        }

        /**

         *Adds a dirty zone to the topology

         *(usually whe a feature of a layer

         *of the topology has been edited)

         */

        public void addDirtyZone(Rectangle2D dirtyZone) {

        }

        public Rectangle2D getDirtyZone() {

                return null;

        }

        public void validate() {

        }

        public int getLayerCount() {

                return super.getLayersCount();

        }

        public int getRuleCount() {

                return 0;

        }

        public FLyrVect getLyr(int lyrIndex) {

                return (FLyrVect) super.getLayer(lyrIndex);

        }

        public AbstractTopologyRule getRule(int ruleIndex) {

                return (AbstractTopologyRule) rules.get(ruleIndex);

        }

        /**

         *Returns if a specified rectangle touch one

         *of the existing dirty zones. If not, probably

         *is needed to add to the dirty zones collection.

         *If true, maybe it could modify the dirty zone.

         */

        public boolean isInDirtyZone(Rectangle2D envelope) {

                return false;

        }

        /**

         *Modify the dirty zone of the specified index

         */

        public void updateDirtyZone(int dirtyZoneIndex, Rectangle2D dirtyZone) {

        }

        public void setMaxNumberOfErrors(int maxNumberOfErrors) {

                this.maxNumberOfErrors = maxNumberOfErrors;

        }

        public int getMaxNumberOfErrors() {

                return maxNumberOfErrors;

        }

        /*

         * @see org.gvsig.topology.ITopologyErrorContainer#addTopologyError(org.gvsig.topology.TopologyError)

         */

        public void addTopologyError(TopologyError topologyError) {

                // TODO Auto-generated method stub

        }

        public void markAsTopologyException(TopologyError topologyError,

                        boolean markAsException) {

                // TODO Auto-generated method stub

        }

        public TopologyError[] getTopologyErrors(String ruleName, int shapeType,

                        FLyrVect sourceLayer, IProjection desiredProjection,

                        int includeExceptions) {

                // TODO Auto-generated method stub

                return null;

        }

        public String getErrorFid() {

                String solution =  Integer.toString(errorFid);

                errorFid++;

                return solution;

        }

}