Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* 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., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

package org.gvsig.raster.wcs.io;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.Hashtable;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Parameters for the WCS provider

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class WCSDataParametersImpl extends AbstractRasterDataParameters implements WCSDataParameters {

        public static final String       DYNCLASS_NAME         = "WCSDataParameters";

        private static final String      FIELD_TIME            = "time";

        private static final String      FIELD_MAXRES          = "maxres";

        private static final String      FIELD_PARAM           = "parameter";

        private static final String      FIELD_SRS             = "srs";

        private static final String      FIELD_FORMAT          = "format";

        private static final String      FIELD_NAME            = "name";

        private static final String      FIELD_SRSSTR          = "srsstr";

        private static final String      FIELD_EXTENT          = "extent";

        private static final String      FIELD_WIDTH           = "width";

        private static final String      FIELD_HEIGHT          = "height";

        private static final String      FIELD_CANCEL          = "cancellable";

        private static final String      FIELD_OVERRIDE        = "override";

        private static final String      FIELD_ONLINERESOURC   = "onlineresources";

        private static final String      FIELD_DEPTH           = "depth";

        private static final String      FIELD_DELETECACHE     = "deletecache";

        private DelegatedDynObject       delegatedDynObject    = null;

        protected static DynClass        DYNCLASS              = null;

        public WCSDataParametersImpl() {

                super();

                initialize();

        }

        protected void initialize() {

                this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

                                .getDynObjectManager().createDynObject(

                                                DYNCLASS);

        }

        public static void registerPersistence() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition("WCSDataParametersImpl_Persistent");

                if( definition == null ) {

                        definition = manager.addDefinition(

                                        WCSDataParametersImpl.class,

                                        "WCSDataParametersImpl_Persistent",

                                        "WCS DataParameters Persistency",

                                        null, 

                                        null

                        );

                        AbstractRasterDataParameters.registerPersistence(definition);

                        definition.addDynFieldObject(FIELD_EXTENT).setClassOfValue(Rectangle2D.class).setMandatory(false);

                        definition.addDynFieldInt(FIELD_WIDTH).setMandatory(false);

                        definition.addDynFieldInt(FIELD_HEIGHT).setMandatory(false);

                        definition.addDynFieldObject(FIELD_MAXRES).setClassOfValue(Point2D.class).setMandatory(false);

                        definition.addDynFieldString(FIELD_FORMAT).setMandatory(false);

                        definition.addDynFieldString(FIELD_PARAM).setMandatory(false);

                        definition.addDynFieldString(FIELD_NAME).setMandatory(false);                        

                        definition.addDynFieldString(FIELD_SRSSTR).setMandatory(false);

                        definition.addDynFieldBoolean(FIELD_OVERRIDE).setMandatory(false);

                        definition.addDynFieldMap(FIELD_ONLINERESOURC).setClassOfItems(String.class).setMandatory(false);

                        definition.addDynFieldString(FIELD_DEPTH).setMandatory(false);

                        definition.addDynFieldString(FIELD_TIME).setMandatory(false);

                }

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set(FIELD_FORMAT, getFormat());

                state.set(FIELD_MAXRES, getMaxResolution());

                state.set(FIELD_PARAM, getParameter());

                state.set(FIELD_DEPTH, getDepth());

                state.set(FIELD_TIME, getTime());

                state.set(FIELD_NAME, getCoverageName());        

                state.set(FIELD_SRSSTR, getSRSCode());

                state.set(FIELD_OVERRIDE, isOverridingHost());

                state.set(FIELD_ONLINERESOURC, getOnlineResource());

                state.set(FIELD_EXTENT, getExtent());

        }

        @SuppressWarnings("unchecked")

        public void loadFromState(PersistentState state)

        throws PersistenceException {

                super.loadFromState(state);

                setFormat(state.getString(FIELD_FORMAT));

                setMaxResolution((Point2D)state.get(FIELD_MAXRES));

                setParameter(state.getString(FIELD_PARAM));

                setDepth(state.getString(FIELD_DEPTH));

                setTime(state.getString(FIELD_TIME));

                setCoverageName(state.getString(FIELD_NAME));

                setSRS(state.getString(FIELD_SRSSTR));

                setOverrideHost(state.getBoolean(FIELD_OVERRIDE));

                if(state.getMap(FIELD_ONLINERESOURC) != null)

                        setOnlineResources(new Hashtable(state.getMap(FIELD_ONLINERESOURC)));

                setExtent((Rectangle2D)state.get(FIELD_EXTENT));

        }

        @SuppressWarnings("deprecation")

        public static void registerDynClass() {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynClass dynClass;

                DynField field;

                if(dynman == null)

                        return;

                if (DYNCLASS == null) {

                        dynClass = AbstractRasterDataParameters.registerDynClass(WCSDataParametersImpl.DYNCLASS_NAME);

                        field = dynClass.addDynField(FIELD_MAXRES);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Maxresolution");

                        field.setType(DataTypes.OBJECT);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_PARAM);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Parameters");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_SRS);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("SRS");

                        field.setType(org.cresques.DataTypes.CRS);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_FORMAT);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Format");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(true);

                        field = dynClass.addDynField(FIELD_NAME);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Name");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(true);

                        field = dynClass.addDynField(FIELD_SRSSTR);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("String that represents the SRS");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(true);

                        field = dynClass.addDynField(FIELD_CANCEL);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Cancellable");

                        field.setType(DataTypes.OBJECT);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_EXTENT);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Extent");

                        field.setType(DataTypes.OBJECT);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_WIDTH);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Width");

                        field.setType(DataTypes.INT);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_HEIGHT);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Height");

                        field.setType(DataTypes.INT);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_OVERRIDE);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Override a host capabilities");

                        field.setType(DataTypes.BOOLEAN);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_ONLINERESOURC);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("online resources");

                        field.setType(DataTypes.MAP);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_DEPTH);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Depth");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_TIME);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Time");

                        field.setType(DataTypes.STRING);

                        field.setMandatory(false);

                        field = dynClass.addDynField(FIELD_DELETECACHE);

                        field.setTheTypeOfAvailableValues(DynField.ANY);

                        field.setDescription("Flag to delete cache the next request");

                        field.setType(DataTypes.BOOLEAN);

                        field.setMandatory(false);

                        DYNCLASS = dynClass;

                }

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#setMaxResolution(java.awt.geom.Point2D)

         */

        public void setMaxResolution(Point2D res) {

                this.setDynValue(FIELD_MAXRES, res);

        }

        public Point2D getMaxResolution() {

                return (Point2D) this.getDynValue(FIELD_MAXRES);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.WCSDataParameters#setParameter(java.lang.String)

         */

        public void setParameter(String parameter) {

                this.setDynValue(FIELD_PARAM, parameter);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#getParameter()

         */

        public String getParameter() {

                return (String) this.getDynValue(FIELD_PARAM);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#getFormat()

         */

        public String getFormat() {

                return (String) this.getDynValue(FIELD_FORMAT);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#setFormat(java.lang.String)

         */

        public void setFormat(String format) {

                this.setDynValue(FIELD_FORMAT, format);

        }

        /**

         * Devuelve el SRS.

         * @return SRS.

         */

        public String getSRSCode() {

                return (String) this.getDynValue(FIELD_SRSSTR);

        }

        /**

         * Inserta el SRS.

         * @param m_srs SRS.

         */

        public void setSRS(String m_srs) {

                this.setDynValue(FIELD_SRSSTR, m_srs);

                setSRS(CRSFactory.getCRS(m_srs));

        }

        public void setSRS(IProjection srs) {

                setDynValue(FIELD_SRS, srs);

        }

        /**

         * Returns the projection

         * @return

         */

        public IProjection getSRS() {

                if (this.getSRSID() == null) {

                        return null;

                }

                return (IProjection) getDynValue(FIELD_SRS);

        }

        public String getSRSID() {

                IProjection srs = (IProjection) getDynValue(FIELD_SRS);

                if (srs == null) {

                        return null;

                }

                return srs.getAbrev();

        }

        public void setSRSID(String srsid) {

                if (srsid == null) {

                        setDynValue(FIELD_SRS, null);

                } else {

                        setDynValue(FIELD_SRS, CRSFactory.getCRS(srsid));

                }

        }

        public String getCoverageName() {

                return (String) this.getDynValue(FIELD_NAME);

        }

        public void setCoverageName(String name) {

                this.setDynValue(FIELD_NAME, name);

        }

        public void setCancellable(ICancellable cancel) {

                this.setDynValue(FIELD_CANCEL, cancel);

        }

        public ICancellable getCancellable() {

                return (ICancellable) this.getDynValue(FIELD_CANCEL);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#setExtent(java.awt.geom.Rectangle2D)

         */

        public void setExtent(Rectangle2D bBox) {

                this.setDynValue(FIELD_EXTENT, bBox);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RemoteStoreParameters#setWidth(int)

         */

        public void setWidth(int w) {

                this.setDynValue(FIELD_WIDTH, new Integer(w));

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RemoteStoreParameters#setHeight(int)

         */

        public void setHeight(int h) {

                this.setDynValue(FIELD_HEIGHT, new Integer(h));

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#getExtent()

         */

        public Rectangle2D getExtent() {

                return (Rectangle2D)getDynValue(FIELD_EXTENT);

        }

        /**

         * Gets the width

         * @return

         */

        public int getWidth() {

                Integer b = (Integer)getDynValue(FIELD_WIDTH);

                if(b != null)

                        return ((Integer)b).intValue();

                return 0;

        }

        /**

         * Gets the height

         * @return

         */

        public int getHeight() {

                Integer b = (Integer)getDynValue(FIELD_HEIGHT);

                if(b != null)

                        return ((Integer)b).intValue();

                return 0;

        }

        /*public void setConnector(Object connector) {

                this.setDynValue(FIELD_CONNECTOR, connector);

        }

        public Object getConnector() {

                return (Object)getDynValue(FIELD_CONNECTOR);

        }*/

        //**********************************************

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.DataStoreParameters#getDataStoreName()

         */

        public String getDataStoreName() {

                return WCSProvider.NAME;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.DataStoreParameters#getDescription()

         */

        public String getDescription() {

                return WCSProvider.DESCRIPTION;

        }

        public String getExplorerName() {

                return WCSServerExplorer.NAME;

        }

        public boolean isValid() {

                return (this.getURI() != null);

        }

        protected DelegatedDynObject getDelegatedDynObject() {

                return delegatedDynObject;

        }

        /*

         * (non-Javadoc)

         * @see java.lang.Object#clone()

         */

        @SuppressWarnings("unchecked")

        public WCSDataParametersImpl clone() {

                WCSDataParametersImpl p = new WCSDataParametersImpl();

                p.setFormat(getFormat());

                p.setHeight(getHeight());

                p.setWidth(getWidth());

                p.setExtent(getExtent());

                p.setCoverageName(getCoverageName());

                p.setOverrideHost(isOverridingHost());

                p.setSRS(getSRS());

                p.setSRS(getSRSCode());

                p.setURI(getURI());

                p.setCancellable(getCancellable());

                p.setOnlineResources((Hashtable<String, String>)this.getDynValue(FIELD_ONLINERESOURC));

                p.setTime(getTime());

                return p;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#getTime()

         */

        public String getTime() {

                return (String) this.getDynValue(FIELD_TIME);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#setTime(java.lang.String)

         */

        public void setTime(String time) {

                this.setDynValue(FIELD_TIME, time);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#isOverridingHost()

         */

        public boolean isOverridingHost() {

                Boolean b = (Boolean)getDynValue(FIELD_OVERRIDE);

                if(b != null)

                        return ((Boolean)b).booleanValue();

                return false;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#setOverrideHost(boolean)

         */

        public void setOverrideHost(boolean over) {

                this.setDynValue(FIELD_OVERRIDE, new Boolean(over));;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#setOnlineResources(java.util.Hashtable)

         */

        public void setOnlineResources(Hashtable<String, String> onlineResources) {

                this.setDynValue(FIELD_ONLINERESOURC, onlineResources);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.wcs.io.WCSDataParameters#getOnlineResource()

         */

        @SuppressWarnings("unchecked")

        public Map<String,String> getOnlineResource() {

                return (Map<String,String>) this.getDynValue(FIELD_ONLINERESOURC);

        }

        /**

         * Gets the URL that should be accessed for an operation performed

         * to the server.

         *

         * @param onlineResources

         */

        public String getOnlineResource(String operation) {

                return (String) getOnlineResource().get(operation);

        }

        public String getDepth() {

                return (String) this.getDynValue(FIELD_DEPTH);

        }

        public void setDepth(String depth) {

                this.setDynValue(FIELD_DEPTH, depth);

        }

        public boolean isSizeFixed() {

                return true;

        }

        public void deleteCache(boolean deleteCache) {

                this.setDynValue(FIELD_DELETECACHE, new Boolean(deleteCache));

        }

        public boolean isDeletingCache() {

                return ((Boolean)getDynValue(FIELD_DELETECACHE)).booleanValue();

        }

}