Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3 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.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.util.Iterator;

import java.util.List;

import javax.json.JsonObject;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableInt;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.exception.CopyParametersException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectEncoder;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynObjectValidateException;

import org.gvsig.tools.persistence.PersistenceFactory;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.persistence.xml.XMLPersistenceManager;

import org.gvsig.tools.util.Validator;

/**

 * @author jmvivo

 *

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractDataParameters implements DataParameters, Validator {

    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractDataParameters.class);

    private Exception validateException;

    @Override

    public Object getDynValue(String name) {

        return getDelegatedDynObject().getDynValue(name);

    }

    public String getProviderName() {

        return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

    }

    public String getDataStoreName() {

        return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

    }

    public String getDescription() {

        return this.getDynClass().getDescription();

    }

    @Override

    public String toString() {

        DynObjectEncoder encoder = ToolsLocator.getDynObjectManager().createSimpleDynObjectEncoder();

        return encoder.encode(this);

    }

    @Override

    public void setDynValue(String name, Object value) {

        DelegatedDynObject delegated = getDelegatedDynObject();

        if (delegated.getDynClass().getDynField(name) != null) {

            delegated.setDynValue(name, value);

        } else {

            try {

                throw new IllegalArgumentException(name);

            } catch (IllegalArgumentException ex) {

                LOGGER.warn("Attribute '" + name + "' is not defined in "

                        + delegated.getDynClass().getFullName() + " definition", ex);

            }

        }

    }

    @Override

    public void clear() {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        manager.clear(this);

    }

    protected void copyValuesTo(DataParameters target) {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        manager.copy(this, target);

    }

    @Override

    public DataParameters getCopy() {

        DataParameters copy;

        try {

            if( this instanceof Cloneable ) {

                copy = (DataParameters) this.clone();

            } else {

                copy = (DataParameters) this.getClass().newInstance();

                this.copyValuesTo(copy);

            }

        } catch (Exception e) {

            throw new CopyParametersException("data parameters", e);

        }

        return copy;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        DynField[] fields = getDelegatedDynObject().getDynClass().getDynFields();

        for (DynField field : fields) {

            if (field.isPersistent()) {

                String name = field.getName();

                Object value = this.getDynValue(name);

                state.set(name, value);

            }

        }

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        @SuppressWarnings("rawtypes")

        Iterator it = state.getNames();

        while (it.hasNext()) {

            String name = (String) it.next();

            try {

                Object value = state.get(name);

                this.setDynValue(name, value);

            } catch (Throwable t) {

                LOGGER.warn("Can't load '" + name + "' property", t);

            }

        }

    }

    @Override

    public void delegate(DynObject dynObject) {

        getDelegatedDynObject().delegate(dynObject);

    }

    @Override

    public DynClass getDynClass() {

        return getDelegatedDynObject().getDynClass();

    }

    @Override

    public boolean hasDynValue(String name) {

        return getDelegatedDynObject().hasDynValue(name);

    }

    @Override

    public void implement(DynClass dynClass) {

        getDelegatedDynObject().implement(dynClass);

    }

    @Override

    public Object invokeDynMethod(String name, Object[] args)

            throws DynMethodException {

        return getDelegatedDynObject().invokeDynMethod(this, name, args);

    }

    @Override

    public Object invokeDynMethod(int code, Object[] args)

            throws DynMethodException {

        return getDelegatedDynObject().invokeDynMethod(this, code, args);

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        try {

            this.getDynClass().validate(this);

        } catch (DynObjectValidateException e) {

            throw new ValidateDataParametersException(e);

        }

    }

    protected void loadPRJ(File file, String parameterName) {

        File prjFile = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + ".prj");

        if (prjFile.exists()) {

            try {

                String contentFile = FileUtils.readFileToString(prjFile);

                if (StringUtils.isNotEmpty(contentFile)) {

                    IProjection crs = CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, contentFile);

                    this.setDynValue(parameterName, crs);

                }

            } catch (IOException e) {

                LOGGER.warn("Couldn't read prj file ''{}''", prjFile.getAbsolutePath());

            }

        }

    }

    protected void loadWLD(File file, String parameterName) {

        File wldFile = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + ".wld");

        if (wldFile.exists()) {

            try {

                List<String> lines = FileUtils.readLines(wldFile);

                if (lines != null && lines.size() == 6) {

                    this.setDynValue(parameterName, lines);

                }

            } catch (IOException e) {

                LOGGER.warn("Couldn't read wld file ''{}''", wldFile.getAbsolutePath());

            }

        }

    }

    @Override

    public byte[] toByteArray() {

            try {

//            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            PersistenceManager persistenceManager = new XMLPersistenceManager();

            ByteArrayOutputStream stream = new ByteArrayOutputStream();

            PersistentState state = persistenceManager.getState(this, false, new MutableInt(1));

            persistenceManager.saveState(state, stream);

            return stream.toByteArray();

        } catch (Exception ex) {

            LOGGER.warn("Can't get byte[] from parameters.",ex);

            return null;

        }

    }

    public static DataParameters fromByteArray(byte[] data) {

        Object x;

        PersistenceManager defaultPersistenceManager = ToolsLocator.getPersistenceManager();

        try {

            PersistenceManager xmlPersistenceManager = new XMLPersistenceManager();

            for (Iterator it = defaultPersistenceManager.getFactories().iterator(); it.hasNext();) {

              PersistenceFactory factory = (PersistenceFactory) it.next();

              xmlPersistenceManager.registerFactory(factory);

            }

            ByteArrayInputStream stream = new ByteArrayInputStream(data);

            x = xmlPersistenceManager.getObject(stream);

            DataParameters parameters = (DataParameters) x;

            return parameters;

        } catch (Exception ex) {

          LOGGER.debug("Can't get parameters from byte[] with XMLPersistenceManager.",ex);

          // Try with the default persistence manager for compatibility

        }

        try {

            ByteArrayInputStream stream = new ByteArrayInputStream(data);

            DataParameters parameters = (DataParameters) defaultPersistenceManager.getObject(stream);

            return parameters;

        } catch (Exception ex) {

            LOGGER.warn("Can't get parameters from byte[].",ex);

            return null;

        }

    }

    @Override

    public boolean equals(Object obj) {

        if( !(obj instanceof DynObject) ) {

            return false;

        }

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        return manager.equals(this, (DynObject) obj);

    }

    @Override

    public int hashCode() {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        return manager.hashCode(this);

    }

    @Override

    public JsonObject toJson() {

        JsonObjectBuilder builder = this.toJsonBuilder();

        return builder.build();

    }

    @Override

    public JsonObjectBuilder toJsonBuilder() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add_class(this);

        builder.addAll(this);

        return builder;

    }

    @Override

    public void fromJson(JsonObject json) {

        Json.addAll(this, json);

    }

    /**

     * Returns an instance of the {@link DynObject} to delegate to.

     *

     * @return the delegate {@link DynObject}

     */

    protected abstract DelegatedDynObject getDelegatedDynObject();

    @Override

    public boolean isValid(Object data, Object... args) {

        try {

            validate();

            return true;

        } catch (Exception e) {

            this.validateException = e;

            return false;

        }

    }

    @Override

    public String getMessage() {

        if(this.validateException == null){

            return null;

        }

        return this.validateException.getMessage();

    }

    @Override

    public Throwable getCause() {

        return this.validateException;

    }

}