Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.util;

import java.io.File;

import java.net.URI;

import java.net.URL;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.tools.ToolsLocator;

import static org.gvsig.tools.dataTypes.DataTypes.URI;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceFactory;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * This class is intended to serve as an aid to the implementation of

 * PropertiesSupport.

 *

 * When we have a class that implements the PropertiesSupport interface, we will

 * use PropertiesSupportHelper to implement it. For this, we will declare a

 * property "propertiesHelper", and we will implement the interface methods

 * delegating in it.

 *

 * <code>

 *      private PropertiesSupportHelper propertiesHelper = new PropertiesSupportHelper();

 *

 *      ...

 *

 *      @Override

 *      public Object getProperty(String key) {

 *          return this.propertiesHelper.getProperty(key);

 *      }

 *

 *      @Override

 *      public void setProperty(String key, Object obj) {

 *          this.propertiesHelper.setProperty(key, obj);

 *      }

 *

 *      @Override

 *      public Map<String,Object> getProperties() { return

 * this.propertiesHelper.getProperties(); }

 * </code> If the class is persistent, we will declare "propertiesHelper" as:

 *

 * <code>

 *      definition.addDynFieldObject("propertiesHelper")

 *          .setClassOfValue(PropertiesSupportHelper.class)

 *          .setMandatory(false);

 * </code>

 *

 * We will add the following code to the "loadFromState" and "saveToState":

 *

 * <code>

 *      // in loadFromState

 *      this.propertiesHelper = (PropertiesSupportHelper) state.get("propertiesHelper");

 *

 *      // in saveToState

 *      state.set("propertiesHelper",propertiesHelper);

 * </code>

 *

 * And we will record the persistence invoking:

 *

 * <code>

 *      new PropertiesSupportHelper.RegisterPersistence().call()

 * </code>

 *

 * Or using <code>Caller</code>:

 *

 * <code>

 *      caller.add(new new PropertiesSupportHelper.RegisterPersistence());

 *      ...

 *      caller.call()

 * </code>

 *

 * @author gvSIG Team

 */

public class PropertiesSupportHelper implements PropertiesSupport, Persistent, Observable {

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

    public static final String PROPERTY_CHANGE = "PropertyChange";

    public static final String PROPERTIES_CHANGE = "PropertiesChange";

    private Map<String, Object> properties = new HashMap<>();

    private ObservableHelper observableHelper;

    @Override

    public Object getProperty(String key) {

        return properties.get(key);

    }

    @Override

    public void setProperty(String key, Object val) {

        properties.put(key, val);

        if (this.observableHelper != null) {

            this.observableHelper.notifyObservers(this, PROPERTY_CHANGE, key, val);

        }

    }

    @Override

    public Map<String, Object> getProperties() {

        return properties;

    }

    public void setProperties(Map<String, Object> properties) {

        this.properties = new HashMap();

        if (properties != null) {

            this.copyFrom(properties);

        }

        if (this.observableHelper != null) {

            this.observableHelper.notifyObservers(this, PROPERTIES_CHANGE, null);

        }

    }

    protected void copyFrom(Map<String, Object> properties) {

        for (Map.Entry<String, Object> entry : properties.entrySet()) {

            String key = entry.getKey();

            if (key == null) {

                continue;

            }

            Object value;

            try {

                value = entry.getValue();

            } catch (Throwable th) {

                if (LOGGER.isDebugEnabled()) {

                    LOGGER.warn("Can't get property " + key + ".", th);

                } else {

                    LOGGER.warn("Can't get property " + key + ".");

                }

                value = null;

            }

            this.properties.put(key, value);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        HashMap<String, Object> toSave = new HashMap<String, Object>();

        for (Map.Entry<String, Object> entry : properties.entrySet()) {

            String key = entry.getKey();

            Object value = entry.getValue();

            if (isPersistent(value)) {

                toSave.put(key, value);

            }

        }

        state.set("properties", toSave);

    }

    private boolean isPersistent(Object obj) {

        if (obj instanceof Boolean

                || obj instanceof String

                || obj instanceof File

                || obj instanceof URL

                || obj instanceof URI

                || obj instanceof Short

                || obj instanceof Integer

                || obj instanceof Long

                || obj instanceof Float

                || obj instanceof Double) {

            return true;

        }

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        PersistenceManager.Factories factories = persistenceManager.getFactories();

        PersistenceFactory factory = factories.get(obj);

        if (factory == null) {

            return false;

        }

        return true;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.properties = new HashMap();

        Map props = (Map) state.get("properties");

        if (props != null) {

            copyFrom(props);

        }

    }

    @Override

    public void addObserver(Observer o) {

        if (this.observableHelper == null) {

            this.observableHelper = new ObservableHelper();

        }

        this.observableHelper.addObserver(o);

    }

    @Override

    public void deleteObserver(Observer o) {

        if (this.observableHelper == null) {

            this.observableHelper = new ObservableHelper();

        }

        this.observableHelper.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        if (this.observableHelper == null) {

            this.observableHelper = new ObservableHelper();

        }

        this.observableHelper.deleteObservers();

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("PropertiesSupportHelper") == null) {

            DynStruct definition = manager.addDefinition(

                    PropertiesSupportHelper.class,

                    "PropertiesSupportHelper",

                    "PropertiesSupportHelper Persistence definition",

                    null,

                    null

            );

            definition.addDynFieldMap("properties")

                    .setClassOfItems(Object.class)

                    .setMandatory(true);

        }

    }

}