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

package org.gvsig.tools.util;

import java.util.Map;

public interface PropertiesSupport {

    public Object getProperty(String name);

    public void setProperty(String name, Object value);

    public Map<String,Object> getProperties();

}

package org.gvsig.tools.util;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

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 {

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

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

    @Override

    public Object getProperty(String key) {

        return properties.get(key);

    }

    @Override

    public void setProperty(String key, Object val) {

        properties.put(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);

        }

    }

    private 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 {

        state.set("properties", properties);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.properties = new HashMap();

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

        if (props != null) {

            copyFrom(props);

        }

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() {

            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);

            }

            return Boolean.TRUE;

        }

    }

}