/branches/v2_0_0_prep/libraries/libTools/src/org/gvsig/tools/persistence/PersistenceManager.java - Diff - Application: gvSIG desktop - gvSIG

Revision 29956 branches/v2_0_0_prep/libraries/libTools/src/org/gvsig/tools/persistence/PersistenceManager.java

     import java.util.Iterator;
     import org.gvsig.tools.dynobject.DynStruct;
     import org.gvsig.tools.persistence.validation.ValidationResult;
     /**
      * <p>This interface contains the necessary methods to get a persistent representation
-...
      */
     public interface PersistenceManager {
     	/**
     	 * <p>Validation Mode -- MANDATORY: Validation is active, so
     	 * <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)}
-...
     	static public final int DISABLED = 0;
     	/**
     	 * <p>Creates a persistent state from an Persistent object.</p>
     	 * <p>
     	 * Creates a persistent state from an Persistent object.
     	 * </p>
+    	 *
     	 * @param obj The Persistent object to be persisted
     	 * @param obj
     	 *            The Persistent object to be persisted
+    	 *
     	 * @return A PersistentState object, which stores the state of the
     	 * provided Persistent Object.
     	 * @return A PersistentState object, which stores the state of the provided
     	 *         Persistent Object.
     	 * @throws PersistenceException
     	 * @throws PersistenceValidateExceptions
     	 */
     	public PersistentState getState(Persistent obj) throws PersistenceException;
     	public PersistentState getState(Persistent obj)
     			throws PersistenceException, PersistenceValidateExceptions;
     	/**
     	 * <p>Instantiates an object from a persistent state. The PersistentState object knows
     	 * the class of the persisted object, and instantiates it by using introspection. The
     	 * object must implement the Persistent interface so that it can understand the
     	 * PersistentState.</p>
+    	 *
+    	 *
     	 * @param state The state of the object to be instantiated
     	 * @return A new object whose state is the same as the provided <code>state</code> object.
+    	 *
+    	 *
     	 * @throws PersistenceException
     	 */
     	public Object create(PersistentState state) throws PersistenceException;
     	public Persistent create(PersistentState state) throws PersistenceException;
     	/**
     	 * <p>Associates an alias with a class. This is similar to a symbolic link, which allows
     	 * to access the class by means of its alias.</p>
+    	 *
+    	 *
     	 * <p>When an alias is defined, it replaces any
     	 * class whose qualified name is equal to the alias. Therefore, this class will never
     	 * be instantiated, and instead the class pointed by the the alias will be instantiated.</p>
+    	 *
+    	 *
     	 * <p>For example, if the following alias is defined:</p>
+    	 *
     	 * <pre>Class aClass = org.gvsig.fmap.mapcontext.rendering.symbols.SimpleMarkerSymbol.class;
-...
     	 * </pre>
     	 * <p>then, SimpleMarkerSymbol will be instantiated instead of ArrowMarkerSymbol from any
     	 * PersistentState which references ArrowMarkerSymbol.</p>
+    	 *
+    	 *
     	 * <p>Aliases are useful to provided backward-compatibility paths (as old unexisting classes
     	 * may be aliased to substitution classes), but are also useful to avoid limitations on
     	 * ClassLoaders. As a Class object is provided, it will be possible to instantiate it even
-...
     	 * <p>Registers persistentClass as Persistent, and associates an attribute definition to that
     	 * class. During a persistence process, the PersistenceManager will validate that a class
     	 * only persists attributes which has been defined in its DynStruct definition.</p>
+    	 *
+    	 *
     	 * @param persistentClass The class to register
     	 * @param definition The definition of the attributes allowed for the persistentClass
     	 */
-...
     	/**
     	 * <p>De-registers a class which has been previously registered using
     	 *  <code>{@link #addDefinition(Class, DynStruct)}</code></p>
+    	 *
+    	 *
     	 * @param persistentClass
     	 */
     	public void removeDefinition(Class persistentClass);
     	/**
     	 * <p>Validates 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>
     	 * represented by the PersistenteState, validation should fail.
     	 * </p>
+    	 *
     	 * <p>Some manager implementations may not support validation. In this case,
     	 * they should always return a positive validation.</p>
     	 * @param state
+    	 *
     	 * @throws PersistenceValidateExceptions
+    	 *
     	 */
     	public void validate(PersistentState state)
     			throws PersistenceValidateExceptions;
     	/**
     	 * <p>
     	 * Validates a persistent state by using the corresponding registered
     	 * attribute definition. <code>mode</code> specifies what to do when a
     	 * definition of a state class is not registered.
     	 * </p>
+    	 *
     	 * @param state
+    	 *
     	 * @return The validation result
     	 * @throws PersistenceValidateExceptions
+    	 *
     	 * @see {@link #setAutoValidation(int)}
     	 * @set {@link #addDefinition(Class, DynStruct)}
+    	 *
     	 */
     	public ValidationResult validate(PersistentState state);
     	public void validate(PersistentState state, int mode)
     			throws PersistenceValidateExceptions;
     	/**
     	 * <p>If the provided persistent class has registered an attribute definition in
     	 * this manager, then this method returns that definition. Otherwise, it returns
     	 * null.</p>
     	 * <p>
     	 * If the provided persistent class has registered an attribute definition
     	 * in this manager, then this method returns that definition. Otherwise, it
     	 * returns null.
     	 * </p>
+    	 *
     	 * @param persistentClass The class whose corresponding attribute definition is
     	 * to be retrieved.
     	 * @param persistentClass
     	 *            The class whose corresponding attribute definition is to be
     	 *            retrieved.
+    	 *
     	 * @return The attribute definition corresponding to the provided persistent class,
     	 * or null otherwise.
     	 * @return The attribute definition corresponding to the provided persistent
     	 *         class, or null otherwise.
     	 */
     	public DynStruct getDefinition(Class persistentClass);
-...
     	 * <p>De-serializes an state from the data read from the provided
     	 * <code>reader</code>. Depending on the implementation the serialized
     	 * data may have different formats, such as XML or binary data.</p>
+    	 *
+    	 *
     	 * <p>Note that a particular implementation will only be able to
     	 * de-serialize data which has been serialized by the same
     	 * implementation.</p>
+    	 *
+    	 *
     	 * @param reader
     	 * @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)
     	 */

Also available in: Unified diff