/ - Diff - Library: org.gvsig.tools - gvSIG

     	 * data which has been serialized by the same implementation.
     	 * </p>
+    	 *
     	 * @param reader
              * @param in
     	 * @return
              * @throws org.gvsig.tools.persistence.exception.PersistenceException
     	 */
     	public PersistentState loadState(InputStream in)
     			throws PersistenceException;
-...
     	 * data which has been serialized by the same implementation.
     	 * </p>
+    	 *
              * @param state
     	 * @param out
     	 * @return
     	 * @throws PersistenceValidateExceptions
     	 */
     	public void saveState(PersistentState state, OutputStream out)
     			throws PersistenceException, PersistenceValidateExceptions;
     	public void saveState(PersistentState state, OutputStream out, boolean collectErrors)
     			throws PersistenceException, PersistenceValidateExceptions;
     	/**
     	 * <p>
     	 * De-serializes an state from the data read from the provided

     import org.gvsig.tools.persistence.PersistentContext;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.persistence.exception.PersistenceTypeNotSupportedException;
     import org.gvsig.tools.persistence.spi.PersistentContextServices;
     import org.gvsig.tools.persistence.spi.PersistentContextServices.ObjectReference;
     import org.gvsig.tools.persistence.spi.PersistentStateServices;
-...
     		// iter all states
     		while (itStates.hasNext()) {
     			curState = (PersistentStateServices) itStates.next();
     			writeState(curState);
                             try {
                                 writeState(curState);
                             } catch(Exception ex) {
                                 if( context.getCollectErrors() ) {
                                     context.addError(ex);
                                 } else {
                                     throw ex;
+                                }
+                            }
+    		}
     		// States end:
-...
     		Object value;
     		itNames = curState.getNames();
                     if( itNames==null || ! itNames.hasNext() ) {
                         // The state is empty. Don't output any thing.
+                    }
     		String theClassName = curState.getTheClassName();
     		String tagName = getXMLValidName( theClassName);
     		DynStruct definition = curState.getDefinition();
     		if( definition != null ) {
                     if( definition != null ) {
     			tagName = getXMLValidName(  curState.getDefinition().getFullName() );
+    		}

     		return context.getRoot().getState();
+    	}
             @Override
     	public void saveState(PersistentState state, OutputStream out)
     			throws PersistenceException, PersistenceValidateExceptions {
     		XMLPersistentStateWriter xmlWriter = getWriterInstance();
                 this.saveState(state, out, false);
+    	}
             @Override
     	public void saveState(PersistentState state, OutputStream out, boolean collectErrors)
     			throws PersistenceException, PersistenceValidateExceptions {
                 ((PersistentContextServices)state.getContext()).setCollectErrors(collectErrors);
                 XMLPersistentStateWriter xmlWriter = getWriterInstance();
                 xmlWriter.write((PersistentStateServices) state, out);
     		xmlWriter.write((PersistentStateServices) state, out);
+    	}
     	protected XMLPersistentStateReader getReaderInstance(){
     		return new XMLPersistentStateReader(this);

     package org.gvsig.tools.persistence.impl;
     import java.io.ByteArrayOutputStream;
     import java.text.MessageFormat;
     import java.util.Map.Entry;
     import org.gvsig.tools.persistence.spi.PersistenceManagerServices;
     import org.gvsig.tools.persistence.spi.PersistentContextServices;
     import org.gvsig.tools.persistence.spi.PersistentContextServices.ObjectReference;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public class DelegatedContainer {
     	private PersistentContextServices context;
     	private PersistenceManagerServices manager;
             private static final Logger logger = LoggerFactory.getLogger(DelegatedContainer.class);
     	private final PersistentContextServices context;
     	private final PersistenceManagerServices manager;
     	public DelegatedContainer(PersistenceManagerServices manager,
     			PersistentContextServices context) {
-...
     	private class WrappedEntry implements Entry {
     		private Entry entry;
     		private final Entry entry;
     		public WrappedEntry(Entry entry) {
     			this.entry = entry;
+    		}
                     @Override
     		public Object getKey() {
     			return getObject(entry.getKey());
+    		}
                     @Override
     		public Object getValue() {
     			return getObject(entry.getValue());
+    		}
                     @Override
     		public Object setValue(Object arg0) {
     			throw new UnsupportedOperationException();
+    		}
-...
     	 * If the object passed as parameter is not a object reference,
     	 * the it is returned as is.
+    	 *
     	 * @param  object
     	 * @param  wrapper
     	 * @return object references by the parameter or it self.
     	 */
     	protected Object getObject(Object wrapper) {
     		if (wrapper instanceof ObjectReference) {
     			ObjectReference ref = (ObjectReference) wrapper;
     			return ref.getObject();
                             try {
                                 return ref.getObject();
                             } catch(Exception ex) {
                                 String state = "(unnown)";
                                 try {
                                     ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                                     this.manager.saveState(ref.getState(), buffer);
                                     state = buffer.toString();
                                 } catch(Exception exx) {
+                                }
                                 String msg = MessageFormat.format(
                                     "Can't retrieve object from persistent state of id {0}. state: {1}",
                                     ref.getId().toString(),
                                     state
                                 );
                                 logger.warn(msg,ex);
                                 throw ex;
+                            }
     		} else if (wrapper instanceof Entry) {
     			return new WrappedEntry((Entry) wrapper);
+    		}

org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.lib/src/main/java/org/gvsig/tools/persistence/impl/AbstractPersistentState.java
936	936
937	937	}
938	938	} catch (RuntimeException e) {
939		logger.info("Can't fix relative paths in " + className, e);
	939	String msg = "Can't fix relative paths in '" + className + "'";
	940	if( context.getCollectErrors() ) {
	941	context.addError(new RuntimeException(msg));
	942	}
	943	logger.info(msg, e);
940	944	}
941	945	}
942	946	}

     public class DelegatedCollection extends DelegatedContainer implements
     		Collection {
     	private Collection delegated;
     	private final Collection delegated;
     	public DelegatedCollection(Collection delegated,
     			PersistenceManagerServices manager, PersistentContextServices context) {
-...
     		this.delegated = delegated;
+    	}
             @Override
     	public boolean add(Object arg0) {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public boolean addAll(Collection arg0) {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public void clear() {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public boolean contains(Object o) {
     		return delegated.contains(getWrapper(o));
+    	}
             @Override
     	public boolean containsAll(Collection arg0) {
     		Iterator iter = arg0.iterator();
     		while (iter.hasNext()) {
-...
     		return true;
+    	}
             @Override
     	public boolean isEmpty() {
     		return delegated.isEmpty();
+    	}
             @Override
     	public Iterator iterator() {
                     Iterator it = delegated.iterator();
     		return this.getWrappedIterator(it);
+    	}
             @Override
     	public boolean remove(Object o) {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public boolean removeAll(Collection arg0) {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public boolean retainAll(Collection arg0) {
     		throw new UnsupportedOperationException();
+    	}
             @Override
     	public Object[] toArray() {
     		Object[] r = new Object[size()];
     		Iterator iter = iterator();
-...
     		return r;
+    	}
             @Override
     	public Object[] toArray(Object[] a) {
         	int size = size();
     		if (a.length < size) {
-...
     		return a;
+    	}
             @Override
     	public int size() {
     		return delegated.size();
+    	}
-...
     	protected ListIterator getWrappedIterator(Iterator iterator) {
     		class DelegatedIterator implements ListIterator {
     			private Iterator delegated;
     			private final Iterator delegated;
     			private ListIterator delegatedListIterator;
     			public DelegatedIterator(Iterator deletaged) {
-...
+    				}
+    			}
                             @Override
     			public boolean hasNext() {
     				return delegated.hasNext();
+    			}
                             @Override
     			public Object next() {
                                     Object o = delegated.next();
     				return getObject(o);
                                 Object o = null;
                                 while( delegated.hasNext() ) {
                                     Object referece = delegated.next();
                                     try {
                                         o = getObject(referece);
                                     } catch(Exception ex) {
                                         if( getContext().getCollectErrors() ) {
                                             getContext().addError(ex);
                                         } else {
                                             throw ex;
+                                        }
+                                    }
                                     if( o != null ) {
                                         break;
+                                    }
+                                }
                                 return o;
+    			}
                             @Override
     			public void remove() {
     				throw new UnsupportedOperationException();
+    			}
                             @Override
     			public void add(Object arg0) {
     				throw new UnsupportedOperationException();
+    			}
                             @Override
     			public boolean hasPrevious() {
     				if (delegatedListIterator == null) {
     					throw new UnsupportedOperationException();
-...
     				return delegatedListIterator.hasPrevious();
+    			}
                             @Override
     			public int nextIndex() {
     				if (delegatedListIterator == null) {
     					throw new UnsupportedOperationException();
-...
     				return delegatedListIterator.nextIndex();
+    			}
                             @Override
     			public Object previous() {
     				if (delegatedListIterator == null) {
     					throw new UnsupportedOperationException();
-...
     				return getObject(delegatedListIterator.previous());
+    			}
                             @Override
     			public int previousIndex() {
     				if (delegatedListIterator == null) {
     					throw new UnsupportedOperationException();
-...
     				return delegatedListIterator.previousIndex();
+    			}
                             @Override
     			public void set(Object arg0) {
     				throw new UnsupportedOperationException();
+    			}

     	 */
     	public PersistenceException getErrors();
     	/**
     	 * Set flag to collect errors. If this flags is true,
     	 * all errors in sets in state, or in saveToState are collected
     	 * for throw later.
+    	 *
     	 * @param collectErrors
     	 */
     	public void setCollectErrors(boolean collectErrors);
     	/**
     	 * Get information about if collect errors or launch it
     	 * when produce.
+    	 *
     	 * @return
     	 */
     	public boolean getCollectErrors();
+    }

     	public PersistentIdentifier getIdentifier(String id) throws PersistenceException;
     	/**
     	 * Set flag to collect errors. If this flags is true,
     	 * all errors in sets in state, or in saveToState are collected
     	 * for throw later.
+    	 *
     	 * @param collectErrors
     	 */
     	public void setCollectErrors(boolean collectErrors);
     	/**
     	 * Get information about if collect errors or launch it
     	 * when produce.
+    	 *
     	 * @return
     	 */
     	public boolean getCollectErrors();
     	/**
     	 * Validate al statetes en the context.
     	 */
     	public void validate(int mode) throws PersistenceValidateExceptions;

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

Revision 1447