/ - Diff - Application: gvSIG desktop - gvSIG

     package org.gvsig.tools.persistence;
     import java.util.HashMap;
     import java.util.Map;
     import org.gvsig.tools.exception.BaseRuntimeException;
     public class PersistenceRuntimeException extends BaseRuntimeException {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = -3729654883985281840L;
     	private final static String MESSAGE_FORMAT = "Error getting or setting the state of the object.";
     	private final static String MESSAGE_KEY = "_PersistenceRuntimeException";
     	protected Map values = new HashMap();
     	public PersistenceRuntimeException(String messageFormat, Throwable cause,
     			String messageKey, long code) {
     		super(messageFormat, cause, messageKey, code);
+    	}
     	public PersistenceRuntimeException(String messageFormat, String messageKey,
     			long code) {
     		super(messageFormat, messageKey, code);
+    	}
     	public PersistenceRuntimeException(Throwable cause) {
     		super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);
+    	}
     	protected void setValue(String name, String value) {
     		this.values.put(name, value);
+    	}
     	protected Map values() {
     		return this.values;
+    	}
+    }

      * @author IVER T.I. <http://www.iver.es>
      */
     public interface PersistenceManager {
     	/**
     	 * <p>Validation Mode -- MANDATORY: Validation is active, so
     	 * {@link PersistenceManager#create(org.gvsig.tools.persistence.PersistentState)}
     	 * and
     	 * {@link PersistenceManager#getState(org.gvsig.tools.persistence.Persistent)}
     	 * will throw validation exceptions if validation errors are found.</p>
     	 * <p>If an undeclared attribute or class is found, this will be considered
     	 * a validation error.</p>
     	 */
     	static public final int MANDATORY = 3;
     	/**
     	 * <p>Validation Mode -- MANDATORY_IF_DECLARED: Validation is active, but
     	 *  it will be only applied to Persistent objectswhich have been registered.
     	 * {@link PersistenceManager#create(org.gvsig.tools.persistence.PersistentState)}
     	 * and
     	 * {@link PersistenceManager#getState(org.gvsig.tools.persistence.Persistent)}
     	 * methods will throw validation exceptions if validation errors are found.</p>
     	 */
     	static public final int MANDATORY_IF_DECLARED = 2;
     	/**
     	 * <p>Validation Mode - DISABLED: No validation is performed at all.
     	 * In this mode, {@link PersistenceManager#ge}</p>
     	 */
     	static public final int DISABLED = 0;
     	/**
     	 * <p>Creates a persistent state from an Persistent object.</p>
-...
     	public void removeDefinition(Class persistentClass);
     	/**
     	 * <p>Validate a persistent state by using the corresponding registered
     	 * <p>Validates a persistent state by using the corresponding registered
     	 * attribute definition. If there is no registered definition for the class
     	 * represented by the PersistenteState, validation should fail.</p>
+    	 *
-...
     	 * @return
     	 */
     	public PersistentState loadState(Reader reader) throws PersistenceException;
     	/**
     	 * <p>Sets the validation which will be applied in
     	 * {@link #getState(Persistent)}, {@link #create(PersistentState)}
     	 * methods. Validation ensures that persisted or de-persisted objects
     	 * match the declared definition (which must have been previously
     	 * registered by using {@link #addDefinition(Class, DynStruct)}).</p>
+    	 *
     	 * <p>When automatic validation is enabled (MANDATORY or
     	 * MANDATORY_IF_DECLARED), a ValidationException will be thrown by
     	 * {@link #getState(Persistent)}, {@link #create(PersistentState)}
     	 * if a validation error is found.</p>
+    	 *
     	 * @param validationMode On of the following values:
     	 * {@link #DISABLED}, {@link #MANDATORY}
     	 * or {@link #MANDATORY_IF_DECLARED}
     	 * @see #validate(PersistentState)
     	 * @see #addDefinition(Class, DynStruct)
+    	 *
     	 * @throws PersistenceException If the mode is not supported by this manager
     	 */
     	public void setAutoValidation(int validationMode) throws PersistenceException;
     	/**
     	 * <p>Gets the validation which will be applied in
     	 * {@link #getState(Persistent)}, {@link #create(PersistentState)} methods.
+    	 *
     	 * @return The current mode for automatic validation: {@link #DISABLED},
     	 * {@link #MANDATORY} or {@link #MANDATORY_IF_DECLARED}
+    	 *
     	 * @see #validate(PersistentState)
     	 * @see #addDefinition(Class, DynStruct)
     	 */
     	public int getAutoValidation();
+    }

branches/v2_0_0_prep/libraries/libTools/src/org/gvsig/tools/persistence/Persistent.java
15	15	*
16	16	* @param state
17	17	*/
18		public void setState(PersistentState state) throws PersistenceException;
	18	public void loadFromState(PersistentState state) throws PersistenceException;
19	19
20	20	}

     			throws PersistenceValueNotFoundException;
     	/**
     	 * Gets a <code>PersistentState</code> property.
     	 * @param name The name of the property to get
+    	 *
     	 * @return The <code>PersistentState</code> property associated to the provided name
     	 * @throws PersistenceValueNotFoundException
     	 */
     	public PersistentState getState(String name)
     			throws PersistenceValueNotFoundException, PersistenceException;
     	/**
     	 * Gets an <code>Object</code> property.
     	 * @param name The name of the property to get
+    	 *
-...
     	public void set(String name, boolean value);
     	/**
     	 * <p>Sets a property of type PersistentState.</p>
+    	 *
     	 * @param name The name of the property to store
     	 * @param it The PersistentState object to be stored in the state.
+    	 *
     	 * @throws PersistenceException
     	 */
     	public void set(String name, PersistentState state) throws PersistenceException;
     	/**
     	 * <p>Sets a property of type Persistent.</p>
+    	 *
     	 * @param name The name of the property to store

     					theClass = Class.forName(className);
+    				}
     				Persistent obj = (Persistent) theClass.newInstance();
     				obj.setState(state);
     				obj.loadFromState(state);
     				return obj;
     			} catch (ClassNotFoundException e) {
     				throw new PersistenceException(e);
-...
     		state.load(reader);
     		return state;
+    	}
     	public int getAutoValidation() {
     		return DISABLED;
+    	}
     	public void setAutoValidation(int validationMode) throws PersistenceException {
     		if (validationMode!=DISABLED) {
     			throw new PersistenceException("Validation not implemented");
+    		}
+    	}
+    }

     import java.util.HashMap;
     import java.util.Map;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.exception.ListBaseException;
     public class PersistenceException extends BaseException {
     public class PersistenceException extends ListBaseException {
     	private static final long serialVersionUID = -3729654883985281840L;
     	private final static String MESSAGE_FORMAT = "Error getting or setting the state of the object.";
     	private final static String MESSAGE_KEY = "_PersistenceException";

     		try {
     			PersistentState state = ToolsLocator.getPersistenceManager().getState(originalList);
     			MyPersistentList resultList = new MyPersistentList();
     			resultList.setState(state);
     			resultList.loadFromState(state);
     			checkEquals(originalList, resultList);
     		} catch (LocatorException e) {
-...
+    		}
     		public void setState(PersistentState state) throws PersistenceException {
     		public void loadFromState(PersistentState state) throws PersistenceException {
     			Iterator it = state.getIterator("myList");
     			list = new ArrayList();
     			while (it.hasNext()) {
-...
     			value = val;
+    		}
     		public void setState(PersistentState state) throws PersistenceException {
     		public void loadFromState(PersistentState state) throws PersistenceException {
     			value = state.getString("miValor");
     			intValue = state.getInt("numero");
+    		}
-...
     			value3 = val;
+    		}
     		public void setState(PersistentState state) throws PersistenceException {
     		public void loadFromState(PersistentState state) throws PersistenceException {
     			value1 = state.get("miObjetito1");
     			value2 = state.get("miObjetito2");
     			value3 = state.get("miObjetito3");

     		return manager.create(manager.createState(value));
+    	}
     	public PersistentState getState(String name)
     			throws PersistenceException {
     		XMLEntity value = this.getData().firstChild(name);
     		if (value == null) {
     			throw new PersistenceValueNotFoundException(name);
+    		}
     		return manager.createState(value);
+    	}
     	public boolean getBoolean(String name)
     			throws PersistenceValueNotFoundException {
     		try {
-...
     		this.getData().putProperty(name, value);
+    	}
     	public void set(String name, PersistentState state) throws PersistenceException {
     		if (state instanceof XMLEntityState) {
     			XMLEntityState lstate = (XMLEntityState) state;
     			XMLEntityState wrappingState = manager.createStateInstance();
     			wrappingState.setTheClass(PersistentState.class);
     			wrappingState.setName(name);
     			wrappingState.getData().addChild(lstate.getXMLEntity());
     			this.getData().addChild(wrappingState.xmlEntity);
+    		}
     		else {
     			// TODO if the state comes from a different implementation, use
     			// TODO the names iterator to get all the values and persist them
     			throw new PersistenceException("set(String, PersistentState): Not yet implemented");
+    		}
+    	}
     	public void set(String name, Persistent obj)
     			throws PersistenceException {
     		XMLEntityState state = (XMLEntityState) manager.getState(obj);
-...
     		public void remove() {
     			throw new UnsupportedOperationException();
+    		}
     		public void setState(PersistentState state) throws PersistenceException {
     		public void loadFromState(PersistentState state) throws PersistenceException {
     			if (state instanceof XMLEntityState) {
     				this.state = (XMLEntityState) state;
     				current = 0;

Application: gvSIG desktop

Revision 28468