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

Revision 301

org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.lib/src/main/java/org/gvsig/tools/dynobject/impl/DefaultDynObjectPagingHelper.java
55	55	}
56	56
57	57	public DefaultDynObjectPagingHelper(DynObjectSet set) throws BaseException {
58		setDynObjectSet(set);
	58	this(set, DEFAULT_PAGE_SIZE);
59	59	}
60	60
61		protected void setDynObjectSet(final DynObjectSet set) throws BaseException {
	61	public DefaultDynObjectPagingHelper(DynObjectSet set, int pageSize)
	62	throws BaseException {
	63	setDynObjectSet(set, pageSize);
	64	}
	65
	66	protected void setDynObjectSet(final DynObjectSet set, int pageSize)
	67	throws BaseException {
62	68	this.set = set;
63	69	setDefaultCalculator(new Sizeable() {
64	70
...	...
71	77	return 0l;
72	78	}
73	79	}
74		});
	80	}, pageSize);
75	81	}
76	82
77	83	public DynObject getDynObjectAt(long index) throws BaseException {
...	...
160	166	loadCurrentPageData();
161	167	}
162	168
163		protected void setDefaultCalculator(Sizeable sizeable) throws BaseException {
164		setCalculator(new DefaultPagingCalculator(sizeable, getMaxPageSize()));
	169	protected void setDefaultCalculator(Sizeable sizeable, int pageSize)
	170	throws BaseException {
	171	setCalculator(new DefaultPagingCalculator(sizeable, pageSize));
165	172	}
166	173
167	174	public int getMaxPageSize() {

      */
     public class DefaultDynObjectManager implements DynObjectManager {
     	private final static Logger LOG = LoggerFactory.getLogger(DefaultDynObjectManager.class);
     	private static DefaultDynObjectManager manager = null;
         private final static Logger LOG = LoggerFactory
             .getLogger(DefaultDynObjectManager.class);
     	private class MethodInfo {
     		int code;
     		DynClass dynClass;
     		DynMethod dynMethod;
     		Class theClass;
         private static DefaultDynObjectManager manager = null;
     		MethodInfo(Class theClass, DynClass dynClass, DynMethod dynMethod, int code) {
     			this.code = code;
     			this.dynClass = dynClass;
     			this.dynMethod = dynMethod;
     			this.theClass = theClass;
+    		}
         private class MethodInfo {
     		String getKey() {
     			return DefaultDynObjectManager.getKey(theClass, dynClass, dynMethod);
+    		}
             int code;
             DynClass dynClass;
             DynMethod dynMethod;
             Class theClass;
     		void check(Class theClass, int code) throws DynMethodException {
     			if( code != this.code) {
     				throw new DynMethodIllegalCodeException(dynMethod.getName(),this.code, code);
+    			}
     			if( theClass != null ) {
     				if( this.theClass == null ) {
     					throw new IllegalDynMethodInvocationException(dynMethod.getName(), theClass);
+    				}
     				if (!this.theClass.isAssignableFrom(theClass)) {
     					throw new IllegalDynMethodInvocationException(dynMethod.getName(),theClass);
+    				}
+    			}
+    		}
             MethodInfo(Class theClass, DynClass dynClass, DynMethod dynMethod,
                 int code) {
                 this.code = code;
                 this.dynClass = dynClass;
                 this.dynMethod = dynMethod;
                 this.theClass = theClass;
+            }
     		void check(DynClass dynClass, int code) throws DynMethodException  {
     			if( code != this.code) {
     				throw new DynMethodIllegalCodeException(dynMethod.getName(),this.code, code);
+    			}
     			if( dynClass != null ) {
     				if( this.dynClass == null ) {
     					throw new IllegalDynMethodInvocationException(dynMethod.getName(), dynClass);
+    				}
     				if( dynClass != this.dynClass || !dynClass.getName().equalsIgnoreCase(this.dynClass.getName()) ) {
     					throw new IllegalDynMethodInvocationException(dynMethod.getName(), dynClass);
+    				}
+    			}
+    		}
+    	}
             String getKey() {
                 return DefaultDynObjectManager
                     .getKey(theClass, dynClass, dynMethod);
+            }
     	private class ClassesNamespaces  {
     		private Map defaultNamespace;
     		private Map namespaces;
     		ClassesNamespaces() {
     			this.namespaces = new HashMap();
     			this.defaultNamespace = new HashMap();
+    		}
     		public Map addNamespace(String name) {
     			Map namespace = new HashMap();
     			this.namespaces.put(name.toLowerCase(), namespace);
     			return namespace;
+    		}
     		public Map getNamespace(String name) {
     			return (Map) this.namespaces.get(name.toLowerCase());
+    		}
             void check(Class theClass, int code) throws DynMethodException {
                 if (code != this.code) {
                     throw new DynMethodIllegalCodeException(dynMethod.getName(),
                         this.code, code);
+                }
                 if (theClass != null) {
                     if (this.theClass == null) {
                         throw new IllegalDynMethodInvocationException(
                             dynMethod.getName(), theClass);
+                    }
                     if (!this.theClass.isAssignableFrom(theClass)) {
                         throw new IllegalDynMethodInvocationException(
                             dynMethod.getName(), theClass);
+                    }
+                }
+            }
     		public void clear() {
     			this.defaultNamespace.clear();
     			this.namespaces.clear();
+    		}
             void check(DynClass dynClass, int code) throws DynMethodException {
                 if (code != this.code) {
                     throw new DynMethodIllegalCodeException(dynMethod.getName(),
                         this.code, code);
+                }
                 if (dynClass != null) {
                     if (this.dynClass == null) {
                         throw new IllegalDynMethodInvocationException(
                             dynMethod.getName(), dynClass);
+                    }
                     if (dynClass != this.dynClass
                         || !dynClass.getName().equalsIgnoreCase(
                             this.dynClass.getName())) {
                         throw new IllegalDynMethodInvocationException(
                             dynMethod.getName(), dynClass);
+                    }
+                }
+            }
+        }
     		public boolean containsClass(String name) {
     			name = name.toLowerCase();
     			if( this.defaultNamespace.containsKey(name)) {
     				return true;
+    			}
     			Iterator it = this.namespaces.values().iterator();
     			while( it.hasNext() ) {
     				Map names = (Map)it.next();
     				if( names.containsKey(name)) {
     					return true;
+    				}
+    			}
     			return false;
+    		}
         private class ClassesNamespaces {
     		public boolean containsClass(String namespace, String name) {
     			name = name.toLowerCase();
     			if( namespace == null ) {
     				return this.defaultNamespace.containsKey(name);
+    			}
     			Map space = this.getNamespace(namespace);
     			if( space == null ) {
     				return false;
+    			}
     			return space.containsKey(name);
+    		}
             private Map defaultNamespace;
             private Map namespaces;
     		public boolean containsClass(DynClass dynClass) {
     			if( this.defaultNamespace.containsValue(dynClass)) {
     				return true;
+    			}
     			Iterator it = this.namespaces.values().iterator();
     			while( it.hasNext() ) {
     				Map names = (Map)it.next();
     				if( names.containsValue(dynClass)) {
     					return true;
+    				}
+    			}
     			return false;
+    		}
             ClassesNamespaces() {
                 this.namespaces = new HashMap();
                 this.defaultNamespace = new HashMap();
+            }
     		public DynClass get(String name, String namespace) {
     			if( namespace == null ) {
     				return (DynClass) this.defaultNamespace.get(name.toLowerCase());
+    			}
     			Map space = this.getNamespace(namespace);
     			if( space == null ) {
     				return null;
+    			}
     			return (DynClass) space.get(name.toLowerCase());
+    		}
     		public Set keySet() {
     			Set keyset = new HashSet();
     			Iterator it = this.iterator();
     			while( it.hasNext() ) {
     				DynClass dynClass = (DynClass) it.next();
     				keyset.add( dynClass.getFullName()) ;
+    			}
     			return keyset;
+    		}
             public Map addNamespace(String name) {
                 Map namespace = new HashMap();
                 this.namespaces.put(name.toLowerCase(), namespace);
                 return namespace;
+            }
     		public Iterator iterator() {
     			final class MyIterator implements Iterator {
     				Iterator current;
     				Iterator others;
     				MyIterator(Iterator main, Iterator others) {
     					this.current = main;
     					this.others = others;
+    				}
     				public boolean hasNext() {
     					if( this.current.hasNext() ) {
     						return true;
+    					}
     					while( this.others.hasNext() )  {
     						this.current = (Iterator) others.next();
     						if( this.current.hasNext() ) {
     							return true;
+    						}
+    					}
     					return false;
+    				}
     				public Object next() {
     					if( this.current.hasNext() ) {
     						return this.current.next();
+    					}
     					while( this.others.hasNext() )  {
     						this.current = (Iterator) others.next();
     						if( this.current.hasNext() ) {
     							return this.current.next();
+    						}
+    					}
     					return null;
+    				}
     				public void remove() {
     					throw new UnsupportedOperationException();
+    				}
+    			}
     			return new MyIterator(this.defaultNamespace.values().iterator(), this.namespaces.values().iterator());
+    		}
     		public Object add(DynStruct dynClass) {
     			String name = dynClass.getName().toLowerCase();
     			Map namespace;
     			if( dynClass.getNamespace() != null ) {
     				namespace = (Map) this.getNamespace(dynClass.getNamespace());
     				if( namespace == null ) {
     					namespace = this.addNamespace(dynClass.getNamespace());
+    				}
     			} else {
     				namespace = this.defaultNamespace;
+    			}
     			if( namespace.containsKey(name) ) {
     				throw new DuplicateDynClassException(dynClass);
+    			}
     			return namespace.put(name, dynClass);
+    		}
     		public void remove(DynStruct dynClass) {
     			String name = dynClass.getName().toLowerCase();
     			Map namespace;
     			if( dynClass.getNamespace() != null ) {
     				namespace = (Map) this.getNamespace(dynClass.getNamespace());
     				if( namespace == null ) {
     					namespace = this.addNamespace(dynClass.getNamespace());
+    				}
     			} else {
     				namespace = this.defaultNamespace;
+    			}
     			if( namespace.containsKey(name) ) {
     				namespace.remove(name);
+    			}
+    		}
     		public int size() {
     			int count = this.defaultNamespace.size();
     			Iterator it = this.namespaces.values().iterator();
     			while( it.hasNext() ) {
     				Map names = (Map)it.next();
     				count += names.size();
+    			}
     			return count;
+    		}
             public Map getNamespace(String name) {
                 return (Map) this.namespaces.get(name.toLowerCase());
+            }
+    	}
     	private Map anonymousClasses;
     	private ClassesNamespaces classes;
     	private Map methodsMap;
     	private MethodInfo[] methods;
             public void clear() {
                 this.defaultNamespace.clear();
                 this.namespaces.clear();
+            }
     	public static DefaultDynObjectManager getManager() {
     		if (manager == null) {
     			manager = new DefaultDynObjectManager();
+    		}
     		return manager;
+    	}
             public boolean containsClass(String name) {
                 name = name.toLowerCase();
                 if (this.defaultNamespace.containsKey(name)) {
                     return true;
+                }
                 Iterator it = this.namespaces.values().iterator();
                 while (it.hasNext()) {
                     Map names = (Map) it.next();
                     if (names.containsKey(name)) {
                         return true;
+                    }
+                }
                 return false;
+            }
             public boolean containsClass(String namespace, String name) {
                 name = name.toLowerCase();
                 if (namespace == null) {
                     return this.defaultNamespace.containsKey(name);
+                }
                 Map space = this.getNamespace(namespace);
                 if (space == null) {
                     return false;
+                }
                 return space.containsKey(name);
+            }
             public boolean containsClass(DynClass dynClass) {
                 if (this.defaultNamespace.containsValue(dynClass)) {
                     return true;
+                }
                 Iterator it = this.namespaces.values().iterator();
                 while (it.hasNext()) {
                     Map names = (Map) it.next();
                     if (names.containsValue(dynClass)) {
                         return true;
+                    }
+                }
                 return false;
+            }
             public DynClass get(String name, String namespace) {
                 if (namespace == null) {
                     return (DynClass) this.defaultNamespace.get(name.toLowerCase());
+                }
                 Map space = this.getNamespace(namespace);
                 if (space == null) {
                     return null;
+                }
                 return (DynClass) space.get(name.toLowerCase());
+            }
             public Set keySet() {
                 Set keyset = new HashSet();
                 Iterator it = this.iterator();
                 while (it.hasNext()) {
                     DynClass dynClass = (DynClass) it.next();
                     keyset.add(dynClass.getFullName());
+                }
                 return keyset;
+            }
             public Iterator iterator() {
                 final class MyIterator implements Iterator {
                     Iterator current;
                     Iterator others;
                     MyIterator(Iterator main, Iterator others) {
                         this.current = main;
                         this.others = others;
+                    }
                     public boolean hasNext() {
                         if (this.current.hasNext()) {
                             return true;
+                        }
                         while (this.others.hasNext()) {
                             this.current = (Iterator) others.next();
                             if (this.current.hasNext()) {
                                 return true;
+                            }
+                        }
                         return false;
+                    }
                     public Object next() {
                         if (this.current.hasNext()) {
                             return this.current.next();
+                        }
                         while (this.others.hasNext()) {
                             this.current = (Iterator) others.next();
                             if (this.current.hasNext()) {
                                 return this.current.next();
+                            }
+                        }
                         return null;
+                    }
                     public void remove() {
                         throw new UnsupportedOperationException();
+                    }
+                }
                 return new MyIterator(this.defaultNamespace.values().iterator(),
                     this.namespaces.values().iterator());
+            }
             public Object add(DynStruct dynClass) {
                 String name = dynClass.getName().toLowerCase();
                 Map namespace;
                 if (dynClass.getNamespace() != null) {
                     namespace = (Map) this.getNamespace(dynClass.getNamespace());
                     if (namespace == null) {
                         namespace = this.addNamespace(dynClass.getNamespace());
+                    }
                 } else {
                     namespace = this.defaultNamespace;
+                }
                 if (namespace.containsKey(name)) {
                     throw new DuplicateDynClassException(dynClass);
+                }
                 return namespace.put(name, dynClass);
+            }
             public void remove(DynStruct dynClass) {
                 String name = dynClass.getName().toLowerCase();
                 Map namespace;
                 if (dynClass.getNamespace() != null) {
                     namespace = (Map) this.getNamespace(dynClass.getNamespace());
                     if (namespace == null) {
                         namespace = this.addNamespace(dynClass.getNamespace());
+                    }
                 } else {
                     namespace = this.defaultNamespace;
+                }
                 if (namespace.containsKey(name)) {
                     namespace.remove(name);
+                }
+            }
             public int size() {
                 int count = this.defaultNamespace.size();
                 Iterator it = this.namespaces.values().iterator();
                 while (it.hasNext()) {
                     Map names = (Map) it.next();
                     count += names.size();
+                }
                 return count;
+            }
+        }
         private Map anonymousClasses;
         private ClassesNamespaces classes;
         private Map methodsMap;
         private MethodInfo[] methods;
         public static DefaultDynObjectManager getManager() {
             if (manager == null) {
                 manager = new DefaultDynObjectManager();
+            }
             return manager;
+        }
         static String getKey(Class theClass, DynClass dynClass, DynMethod dynMethod) {
         	return DefaultDynObjectManager.getKey(theClass, dynClass, dynMethod.getName());
             return DefaultDynObjectManager.getKey(theClass, dynClass,
                 dynMethod.getName());
+        }
         static String getKey(Class theClass, DynClass dynClass, String methodName) {
     		if( dynClass == null ) {
     			return theClass.getName() + ":" + methodName;
     		} else {
     			return dynClass.getName() + ":" + methodName;
+    		}
             if (dynClass == null) {
                 return theClass.getName() + ":" + methodName;
             } else {
                 return dynClass.getName() + ":" + methodName;
+            }
+        }
         public DefaultDynObjectManager() {
             this.classes = new ClassesNamespaces();
             this.anonymousClasses = new HashMap();
             this.methodsMap = new HashMap();
             this.methods = null;
+        }
     	public DefaultDynObjectManager() {
     		this.classes = new ClassesNamespaces();
     		this.anonymousClasses = new HashMap();
     		this.methodsMap = new HashMap();
     		this.methods = null;
+    	}
         public DynClass createDynClass(String name, String description) {
             return new DefaultDynClass(this, name, description);
+        }
     	public DynClass createDynClass(String name, String description) {
     		return new DefaultDynClass(this, name, description);
+    	}
         public DynClass createDynClass(String namespace, String name,
             String description) {
             return new DefaultDynClass(this, namespace, name, description);
+        }
     	public DynClass createDynClass(String namespace, String name, String description) {
     		return new DefaultDynClass(this, namespace, name, description);
+    	}
         public void add(DynClass dynClass) {
             try {
                 ((DefaultDynClass) dynClass).check();
             } catch (Exception ex) {
                 throw new DynObjectRuntimeException(ex);
+            }
             this.classes.add(dynClass);
             LOG.trace("Add DynClass definition {}.",
                 new Object[] { dynClass.getFullName() });
     	public void add(DynClass dynClass) {
     		try {
     			((DefaultDynClass)dynClass).check();
     		} catch(Exception ex) {
     			throw new DynObjectRuntimeException(ex);
+    		}
     		this.classes.add( dynClass);
     		LOG.trace("Add DynClass definition {}.", new Object[] { dynClass.getFullName() });
+        }
+    	}
         public DynClass add(String name, String description) {
             DynClass dynClass =
                 (DynClass) this.classes.get(name.toLowerCase(), null);
             if (dynClass == null) {
                 dynClass = this.createDynClass(name, description);
                 this.add(dynClass);
+            }
             return dynClass;
+        }
     	public DynClass add(String name, String description) {
     		DynClass dynClass = (DynClass) this.classes.get(name.toLowerCase(), null);
     		if (dynClass == null) {
     			dynClass = this.createDynClass(name, description);
     			this.add(dynClass);
+    		}
     		return dynClass;
+    	}
         public DynClass add(String name) {
             return this.add(name, null);
+        }
     	public DynClass add(String name) {
     		return this.add(name, null);
+    	}
         public void remove(DynStruct dynClass) {
             this.classes.remove(dynClass);
+        }
     	public void remove(DynStruct dynClass)  {
     		this.classes.remove(dynClass);
+    	}
         // public static String getFullName(String namespace, String name) {
         // if( namespace == null ) {
         // return name;
         // }
         // return namespace + ":" + name;
         // }
         // public static String[] splitFullName(String fullname) {
         // String[] name = new String[] { null, fullname };
         // int x=fullname.indexOf(':');
         // if( x>-1 ) {
         // name[0] = fullname.substring(0, x);
         // name[1] = fullname.substring(x+1);
         // }
         // return name;
         //
         // }
     //	public static String  getFullName(String namespace, String name) {
     //    	if( namespace == null ) {
     //    		return name;
     //    	}
     //    	return namespace + ":" + name;
     //    }
     //	public static String[] splitFullName(String fullname) {
     //		String[] name = new String[] { null, fullname };
     //		int x=fullname.indexOf(':');
     //		if( x>-1 ) {
     //			name[0] = fullname.substring(0, x);
     //			name[1] = fullname.substring(x+1);
     //		}
     //		return name;
     //
     //	}
     	public DynClass get(String theName) {
     		DynClassName name = createDynClassName(theName);
     		return this.get(name.getNamespace(),name.getName());
+    	}
         public DynClass get(String theName) {
             DynClassName name = createDynClassName(theName);
             return this.get(name.getNamespace(), name.getName());
+        }
     	public DynClass get(String namespace, String name ) {
     		return (DynClass) this.classes.get(name,namespace);
+    	}
         public DynClass get(String namespace, String name) {
             return (DynClass) this.classes.get(name, namespace);
+        }
     	public DynClass get(DynClass[] superClasses) {
     		StringBuffer name = new StringBuffer();
     		for( int i=0; i<superClasses.length; i++) {
     			name.append(superClasses[i].getName()).append("+");
+    		}
     		DefaultDynClass dynClass = (DefaultDynClass) this.anonymousClasses.get(name.toString());
     		if( dynClass == null ) {
     			dynClass = new DefaultDynClass(this, name.toString(), null, superClasses);
     			dynClass.setAnonymous(true);
+    		}
     		return dynClass;
+    	}
         public DynClass get(DynClass[] superClasses) {
             StringBuffer name = new StringBuffer();
             for (int i = 0; i < superClasses.length; i++) {
                 name.append(superClasses[i].getName()).append("+");
+            }
             DefaultDynClass dynClass =
                 (DefaultDynClass) this.anonymousClasses.get(name.toString());
             if (dynClass == null) {
                 dynClass =
                     new DefaultDynClass(this, name.toString(), null, superClasses);
                 dynClass.setAnonymous(true);
+            }
             return dynClass;
+        }
     	public int getCount() {
     		return this.classes.size();
+    	}
         public int getCount() {
             return this.classes.size();
+        }
     	public List getNames() {
     		String[] names = (String[]) this.classes.keySet().toArray();
     		Arrays.sort(names);
     		return Collections.unmodifiableList(Arrays.asList(names));
+    	}
         public List getNames() {
             String[] names = (String[]) this.classes.keySet().toArray();
             Arrays.sort(names);
             return Collections.unmodifiableList(Arrays.asList(names));
+        }
     	public boolean has(String name) {
     		return this.classes.containsClass(name);
+    	}
         public boolean has(String name) {
             return this.classes.containsClass(name);
+        }
     	public boolean has(String namespace ,String name) {
     		return this.classes.containsClass(namespace, name);
+    	}
         public boolean has(String namespace, String name) {
             return this.classes.containsClass(namespace, name);
+        }
     	public Iterator interator() {
     		return this.classes.iterator();
+    	}
     	public DynObject createDynObject(String dynClassName) {
     		DynClassName name = createDynClassName(dynClassName);
     		return this.createDynObject(name.getName(), name.getNamespace());
+    	}
         public Iterator interator() {
             return this.classes.iterator();
+        }
     	public DynObject createDynObject(String dynClassName, String namespace) {
     		DynClass dynClass = (DynClass) this.classes.get(dynClassName, namespace);
     		if (dynClass == null) {
     			throw new IllegalArgumentException("Can't locate class '"
     					+ createDynClassName(namespace, dynClassName).getFullName()
     					+ "'.");
+    		}
     		return this.createDynObject(dynClass);
+    	}
         public DynObject createDynObject(String dynClassName) {
             DynClassName name = createDynClassName(dynClassName);
             return this.createDynObject(name.getName(), name.getNamespace());
+        }
     	public DynObject createDynObject(DynStruct dynClass) {
     		return new DefaultDynObject(dynClass);
+    	}
         public DynObject createDynObject(String dynClassName, String namespace) {
     	public void consolide() {
     		Iterator it = this.classes.iterator();
     		while( it.hasNext() ) {
     			DefaultDynClass dc = (DefaultDynClass) it.next();
     			dc.consolide();
+    		}
     		it = this.anonymousClasses.values().iterator();
     		while( it.hasNext() ) {
     			DefaultDynClass dc = (DefaultDynClass) it.next();
     			dc.consolide();
+    		}
+    	}
             DynClass dynClass =
                 (DynClass) this.classes.get(dynClassName, namespace);
             if (dynClass == null) {
                 throw new IllegalArgumentException("Can't locate class '"
                     + createDynClassName(namespace, dynClassName).getFullName()
                     + "'.");
+            }
             return this.createDynObject(dynClass);
+        }
         public DynObject createDynObject(DynStruct dynClass) {
             return new DefaultDynObject(dynClass);
+        }
     	public int registerDynMethod(DynClass dynClass, DynMethod dynMethod) {
     		((DefaultDynClass)dynClass).addMethod(dynMethod);
     		return registerDynMethod(null, dynClass, dynMethod);
+    	}
         public void consolide() {
             Iterator it = this.classes.iterator();
             while (it.hasNext()) {
                 DefaultDynClass dc = (DefaultDynClass) it.next();
                 dc.consolide();
+            }
             it = this.anonymousClasses.values().iterator();
             while (it.hasNext()) {
                 DefaultDynClass dc = (DefaultDynClass) it.next();
                 dc.consolide();
+            }
+        }
     	public int registerDynMethod(Class theClass, DynMethod dynMethod) {
     		return registerDynMethod(theClass, null, dynMethod);
+    	}
         public int registerDynMethod(DynClass dynClass, DynMethod dynMethod) {
             ((DefaultDynClass) dynClass).addMethod(dynMethod);
             return registerDynMethod(null, dynClass, dynMethod);
+        }
     	int registerDynMethod(Class theClass, DynClass dynClass, DynMethod dynMethod) {
     		MethodInfo info = new MethodInfo(theClass, dynClass, dynMethod, 0);
     		MethodInfo oldInfo = (MethodInfo) methodsMap.get(info.getKey());
     		if (oldInfo != null) {
     			// Update the method info
     			oldInfo.dynClass = dynClass;
     			oldInfo.dynMethod = dynMethod;
     			return oldInfo.code;
+    		}
     		if (methods == null) {
     			methods = new MethodInfo[1];
     			info.code = 0;
     		} else {
     			MethodInfo[] temp1 = new MethodInfo[methods.length + 1];
     			System.arraycopy(methods, 0, temp1, 0, methods.length);
     			info.code = temp1.length - 1;
     			methods = temp1;
+    		}
     		methods[info.code] = info;
     		methodsMap.put(info.getKey(), info);
         public int registerDynMethod(Class theClass, DynMethod dynMethod) {
             return registerDynMethod(theClass, null, dynMethod);
+        }
     		return info.code;
+    	}
         int registerDynMethod(Class theClass, DynClass dynClass, DynMethod dynMethod) {
             MethodInfo info = new MethodInfo(theClass, dynClass, dynMethod, 0);
             MethodInfo oldInfo = (MethodInfo) methodsMap.get(info.getKey());
             if (oldInfo != null) {
                 // Update the method info
                 oldInfo.dynClass = dynClass;
                 oldInfo.dynMethod = dynMethod;
                 return oldInfo.code;
+            }
             if (methods == null) {
                 methods = new MethodInfo[1];
                 info.code = 0;
             } else {
                 MethodInfo[] temp1 = new MethodInfo[methods.length + 1];
                 System.arraycopy(methods, 0, temp1, 0, methods.length);
                 info.code = temp1.length - 1;
                 methods = temp1;
+            }
             methods[info.code] = info;
             methodsMap.put(info.getKey(), info);
     	public Object invokeDynMethod(Object self, int code, DynObject context) throws DynMethodException{
             return info.code;
+        }
     		try {
     			/*
     			 * Intentamos ejecutar la operacion, y si peta ya haremos las
     			 * comprobaciones oportunas para lanzar la excepcion que toque.
+    			 *
     			 * Asi evitamos codigo de comprobacion para los casos que valla bien
     			 * que deberian ser la mayoria.
     			 */
     			return methods[code].dynMethod.invoke(self, context);
     		} catch (RuntimeException e) {
     			getDynMethod(self, code);
     			throw e;
     		} catch (DynMethodException e) {
     			getDynMethod(self, code);
     			throw e;
+    		}
         public Object invokeDynMethod(Object self, int code, DynObject context)
             throws DynMethodException {
+    	}
             try {
                 /*
                  * Intentamos ejecutar la operacion, y si peta ya haremos las
                  * comprobaciones oportunas para lanzar la excepcion que toque.
+                 *
                  * Asi evitamos codigo de comprobacion para los casos que valla bien
                  * que deberian ser la mayoria.
                  */
                 return methods[code].dynMethod.invoke(self, context);
             } catch (RuntimeException e) {
                 getDynMethod(self, code);
                 throw e;
             } catch (DynMethodException e) {
                 getDynMethod(self, code);
                 throw e;
+            }
     	public int getDynMethodCode(DynClass dynClass, String methodName) throws DynMethodException  {
     		String key = DefaultDynObjectManager.getKey(null, dynClass, methodName);
     		MethodInfo info = (MethodInfo) methodsMap.get(key);
     		if( info == null ) {
     			throw new IllegalDynMethodException(methodName, dynClass);
+    		}
     		info.check(dynClass, info.code);
     		return info.code;
+    	}
+        }
     	public int getDynMethodCode(Class theClass, String methodName) throws DynMethodException {
     		String key = DefaultDynObjectManager.getKey(theClass, null, methodName);
     		MethodInfo info = (MethodInfo) methodsMap.get(key);
     		if( info == null ) {
     			throw new IllegalDynMethodException(methodName, theClass);
+    		}
     		info.check(theClass, info.code);
     		return info.code;
+    	}
         public int getDynMethodCode(DynClass dynClass, String methodName)
             throws DynMethodException {
             String key = DefaultDynObjectManager.getKey(null, dynClass, methodName);
             MethodInfo info = (MethodInfo) methodsMap.get(key);
             if (info == null) {
                 throw new IllegalDynMethodException(methodName, dynClass);
+            }
             info.check(dynClass, info.code);
             return info.code;
+        }
     	public DynMethod getDynMethod(int code) throws DynMethodException {
     		if (code >= methods.length) {
     			throw new DynMethodNotSupportedException(code, "{null}");
+    		}
     		MethodInfo info = methods[code];
     		info.check((Class)null, code);
     		return info.dynMethod;
+    	}
         public int getDynMethodCode(Class theClass, String methodName)
             throws DynMethodException {
             String key = DefaultDynObjectManager.getKey(theClass, null, methodName);
             MethodInfo info = (MethodInfo) methodsMap.get(key);
             if (info == null) {
                 throw new IllegalDynMethodException(methodName, theClass);
+            }
             info.check(theClass, info.code);
             return info.code;
+        }
     	public DynMethod getDynMethod(Object obj, int code)
     			throws DynMethodException {
     		return getDynMethod(obj.getClass(), code);
+    	}
         public DynMethod getDynMethod(int code) throws DynMethodException {
             if (code >= methods.length) {
                 throw new DynMethodNotSupportedException(code, "{null}");
+            }
             MethodInfo info = methods[code];
             info.check((Class) null, code);
             return info.dynMethod;
+        }
     	public DynMethod getDynMethod(Class theClass, int code)
     			throws DynMethodException {
     		if (code >= methods.length) {
     			throw new DynMethodNotSupportedException(code, theClass.getName());
+    		}
     		MethodInfo info = methods[code];
     		info.check(theClass, code);
     		return info.dynMethod;
+    	}
         public DynMethod getDynMethod(Object obj, int code)
             throws DynMethodException {
             return getDynMethod(obj.getClass(), code);
+        }
     	public DynMethod getDynMethod(DynClass dynClass, int code)
     			throws DynMethodException {
     		if (code >= methods.length) {
     			throw new DynMethodNotSupportedException(code, dynClass.getName());
+    		}
     		MethodInfo info = methods[code];
     		info.check(dynClass, code);
     		return info.dynMethod;
+    	}
         public DynMethod getDynMethod(Class theClass, int code)
             throws DynMethodException {
             if (code >= methods.length) {
                 throw new DynMethodNotSupportedException(code, theClass.getName());
+            }
             MethodInfo info = methods[code];
             info.check(theClass, code);
             return info.dynMethod;
+        }
     	public DynMethod getDynMethod(DynObject dynObject, int code)
     			throws DynMethodException {
     		return getDynMethod(dynObject.getDynClass(), code);
+    	}
         public DynMethod getDynMethod(DynClass dynClass, int code)
             throws DynMethodException {
             if (code >= methods.length) {
                 throw new DynMethodNotSupportedException(code, dynClass.getName());
+            }
             MethodInfo info = methods[code];
             info.check(dynClass, code);
             return info.dynMethod;
+        }
     	public void validate(DynObject object) {
     		// TODO
     		return;
+    	}
     	public Class getDefaultClassOfType(int type) {
     		return ToolsLocator.getDataTypesManager().getDefaultClass(type);
+    	}
         public DynMethod getDynMethod(DynObject dynObject, int code)
             throws DynMethodException {
             return getDynMethod(dynObject.getDynClass(), code);
+        }
     	public Map importDynClassDefinitions(InputStream resource,
     			ClassLoader loader) throws XmlPullParserException, IOException {
     		return new DynClassImportHelper().importDefinitions(resource, loader, null);
+    	}
         public void validate(DynObject object) {
             // TODO
             return;
+        }
     	public Map importDynClassDefinitions(XmlPullParser parser,
     			ClassLoader loader, String defaultNamespace) throws XmlPullParserException, IOException {
     		return new DynClassImportHelper().importDefinitions(parser, loader, defaultNamespace);
+    	}
         public Class getDefaultClassOfType(int type) {
             return ToolsLocator.getDataTypesManager().getDefaultClass(type);
+        }
     	public Map importDynClassDefinitions(InputStream resource,
     			ClassLoader loader, String defaultNamespace)
     			throws XmlPullParserException, IOException {
     		return new DynClassImportHelper().importDefinitions(resource, loader, defaultNamespace);
+    	}
         public Map importDynClassDefinitions(InputStream resource,
             ClassLoader loader) throws XmlPullParserException, IOException {
             return new DynClassImportHelper().importDefinitions(resource, loader,
                 null);
+        }
         public Map importDynClassDefinitions(XmlPullParser parser,
             ClassLoader loader, String defaultNamespace)
             throws XmlPullParserException, IOException {
             return new DynClassImportHelper().importDefinitions(parser, loader,
                 defaultNamespace);
+        }
         public Map importDynClassDefinitions(InputStream resource,
             ClassLoader loader, String defaultNamespace)
             throws XmlPullParserException, IOException {
             return new DynClassImportHelper().importDefinitions(resource, loader,
                 defaultNamespace);
+        }
         public DynObjectPagingHelper createDynObjectPagingHelper(DynObjectSet set)
             throws BaseException {
             return new DefaultDynObjectPagingHelper(set);
+        }
     	public DynClassName createDynClassName(String namespace, String name) {
     		return new DefaultDynClassName(namespace, name);
+    	}
         public DynObjectPagingHelper createDynObjectPagingHelper(DynObjectSet set,
             int pageSize) throws BaseException {
             return new DefaultDynObjectPagingHelper(set, pageSize);
+        }
     	public DynClassName createDynClassName(String name) {
     		return new DefaultDynClassName(name);
+    	}
         public DynClassName createDynClassName(String namespace, String name) {
             return new DefaultDynClassName(namespace, name);
+        }
         public DynClassName createDynClassName(String name) {
             return new DefaultDynClassName(name);
+        }
+    }

      */
     public interface DynObjectManager {
     	/**
     	 * Null value for method id.
+    	 *
     	 * This value not is a value valid for a code of method.
     	 */
     	public int NULLCODE = -1;
         /**
          * Null value for method id.
+         *
          * This value not is a value valid for a code of method.
          */
         public int NULLCODE = -1;
     	/**
     	 * Create a instance of DynClass with the name and description
     	 * Indicated as parameters.
+    	 *
     	 * @param name, the name used for DynClass name.
     	 * @param description, the description associated to the
     	 * 			new DynClass.
+    	 *
     	 * @return the DynClass created.
     	 */
     	public DynClass createDynClass(String name, String description);
         /**
          * Create a instance of DynClass with the name and description
          * Indicated as parameters.
+         *
          * @param name
          *            , the name used for DynClass name.
          * @param description
          *            , the description associated to the
          *            new DynClass.
+         *
          * @return the DynClass created.
          */
         public DynClass createDynClass(String name, String description);
     	/**
     	 * Create a instance of DynClass with the name and description
     	 * Indicated as parameters.
+    	 *
     	 * @param namespace, the namespace used for the new DynClass.
+    	 *
     	 * @param name, the name used for the new DynClass.
+    	 *
     	 * @param description, the description associated to the
     	 * 			new DynClass.
+    	 *
     	 * @return the DynClass created.
+    	 *
     	 */
     	public DynClass createDynClass(String namespace, String name, String description);
         /**
          * Create a instance of DynClass with the name and description
          * Indicated as parameters.
+         *
          * @param namespace
          *            , the namespace used for the new DynClass.
+         *
          * @param name
          *            , the name used for the new DynClass.
+         *
          * @param description
          *            , the description associated to the
          *            new DynClass.
+         *
          * @return the DynClass created.
+         *
          */
         public DynClass createDynClass(String namespace, String name,
             String description);
     	/**
     	 * Load the classes defined in the resource and return a Map
     	 * with its.
     	 * The classes do not be registered in the manager.
+    	 *
     	 * @param resource, XML with the definition of dynamic
     	 * 			classes.
+    	 *
     	 * @param loader, loader used to load classes used in
     	 * 			"classOfValue" in the resource.
+    	 *
     	 * @param defaultNamespace, namespace used in classes that do not
     	 * 			specify a namespace in the resource.
+    	 *
     	 * @return The Map of loaded dynamic classes
+    	 *
     	 * @throws XmlPullParserException
     	 * @throws IOException
     	 */
     	public Map importDynClassDefinitions(InputStream resource, ClassLoader loader, String defaultNamespace)throws XmlPullParserException, IOException;
     	/**
     	 * Load the classes defined in the resource.
     	 * When the class do not specify a namespace this is set
     	 * to null.
+    	 *
     	 * The classes do not be registered in the manager.
+    	 *
     	 * @param resource, XML with the definition of dynamic
     	 * 			classes.
+    	 *
     	 * @param loader, loader used to load classes used in
     	 * 			"classOfValue" in the resource.
+    	 *
     	 * @return The Map of loaded dynamic classes
+    	 *
     	 * @throws XmlPullParserException
     	 * @throws IOException
     	 */
     	public Map importDynClassDefinitions(InputStream resource, ClassLoader loader)throws XmlPullParserException, IOException;
         /**
          * Load the classes defined in the resource and return a Map
          * with its.
          * The classes do not be registered in the manager.
+         *
          * @param resource
          *            , XML with the definition of dynamic
          *            classes.
+         *
          * @param loader
          *            , loader used to load classes used in
          *            "classOfValue" in the resource.
+         *
          * @param defaultNamespace
          *            , namespace used in classes that do not
          *            specify a namespace in the resource.
+         *
          * @return The Map of loaded dynamic classes
+         *
          * @throws XmlPullParserException
          * @throws IOException
          */
         public Map importDynClassDefinitions(InputStream resource,
             ClassLoader loader, String defaultNamespace)
             throws XmlPullParserException, IOException;
     	/**
     	 * Load the classes defined in the resource.
     	 * When the class do not specify a namespace this is set
     	 * to null.
+    	 *
     	 * The classes do not be registered in the manager.
+    	 *
     	 * @param parser, XML parser used in the definition of dynamic
     	 * 			classes.
+    	 *
     	 * @param loader, loader used to load classes used in
     	 * 			"classOfValue" in the resource.
+    	 *
     	 * @param defaultNamespace, namespace used in classes that do not
     	 * 			specify a namespace in the resource.
+    	 *
     	 * @return The Map of loaded dynamic classes
+    	 *
     	 * @throws XmlPullParserException
     	 * @throws IOException
     	 */
     	public Map importDynClassDefinitions(XmlPullParser parser, ClassLoader loader, String defaultNamespace)throws XmlPullParserException, IOException;
     	/**
     	 * A?ade la dynClass a la lista de clases registradas.
     	 * Falla lanzando una excepcion si ya existe una clase registrada con ese
     	 * nombre en ese namespace.
+    	 *
     	 * @param dynClass
     	 * @throws DuplicateDynClassException
     	 */
     	public void add(DynClass dynClass) throws DuplicateDynClassException;
         /**
          * Load the classes defined in the resource.
          * When the class do not specify a namespace this is set
          * to null.
+         *
          * The classes do not be registered in the manager.
+         *
          * @param resource
          *            , XML with the definition of dynamic
          *            classes.
+         *
          * @param loader
          *            , loader used to load classes used in
          *            "classOfValue" in the resource.
+         *
          * @return The Map of loaded dynamic classes
+         *
          * @throws XmlPullParserException
          * @throws IOException
          */
         public Map importDynClassDefinitions(InputStream resource,
             ClassLoader loader) throws XmlPullParserException, IOException;
     	/**
     	 * Create and add to the manager a class with the name
     	 * passed as parameter in the default namespace.
+    	 *
     	 * @param name
     	 * @param description
     	 * @return the new class created.
     	 */
     	public DynClass add(String name, String description);
         /**
          * Load the classes defined in the resource.
          * When the class do not specify a namespace this is set
          * to null.
+         *
          * The classes do not be registered in the manager.
+         *
          * @param parser
          *            , XML parser used in the definition of dynamic
          *            classes.
+         *
          * @param loader
          *            , loader used to load classes used in
          *            "classOfValue" in the resource.
+         *
          * @param defaultNamespace
          *            , namespace used in classes that do not
          *            specify a namespace in the resource.
+         *
          * @return The Map of loaded dynamic classes
+         *
          * @throws XmlPullParserException
          * @throws IOException
          */
         public Map importDynClassDefinitions(XmlPullParser parser,
             ClassLoader loader, String defaultNamespace)
             throws XmlPullParserException, IOException;
     	/**
     	 * Create and add to the manager a class with the name
     	 * passed as parameter in the default namespace.
+    	 *
     	 * @param name
     	 * @param description
     	 * @return the new class created.
     	 */
     	public DynClass add(String name);
         /**
          * A?ade la dynClass a la lista de clases registradas.
          * Falla lanzando una excepcion si ya existe una clase registrada con ese
          * nombre en ese namespace.
+         *
          * @param dynClass
          * @throws DuplicateDynClassException
          */
         public void add(DynClass dynClass) throws DuplicateDynClassException;
     	public void remove(DynStruct dynClass);
     	/**
     	 * Obtiene  la clase asociado al nombre indicado.
+    	 *
     	 * Si se indica un nombre con namespace la buscara en
     	 * ese namespace. if not se usara el namespace por
     	 * defecto.
+    	 *
     	 * @param name
     	 *            , nombre de la clase que queremos obtener.
     	 * @return la clase requerida.
     	 */
     	public DynClass get(String name);
     	/**
     	 * Obtiene el la clase asociado al nombre indicado dentro del
     	 * namespace pedido.
+    	 *
     	 * @param name
     	 *            , nombre de la clase que queremos obtener.
     	 * @return la clase requerida.
     	 */
     	public DynClass get(String namespace, String name);
         /**
          * Create and add to the manager a class with the name
          * passed as parameter in the default namespace.
+         *
          * @param name
          * @param description
          * @return the new class created.
          */
         public DynClass add(String name, String description);
     	/**
     	 * Comprueba si esta registrada una clase.
+    	 *
     	 * @return true si la clase "name" esta registrada, false si no.
     	 */
     	public boolean has(String name);
         /**
          * Create and add to the manager a class with the name
          * passed as parameter in the default namespace.
+         *
          * @param name
          * @param description
          * @return the new class created.
          */
         public DynClass add(String name);
     	/**
     	 * Comprueba si esta registrada una clase.
+    	 *
     	 * @return true si la clase "name" esta registrada, false si no.
     	 */
     	public boolean has(String namespace, String name);
         public void remove(DynStruct dynClass);
     	/**
     	 * Return the count of registered DynClass.
+    	 *
     	 * @return count of DynClass
     	 */
     	public int getCount();
         /**
          * Obtiene la clase asociado al nombre indicado.
+         *
          * Si se indica un nombre con namespace la buscara en
          * ese namespace. if not se usara el namespace por
          * defecto.
+         *
          * @param name
          *            , nombre de la clase que queremos obtener.
          * @return la clase requerida.
          */
         public DynClass get(String name);
     	/**
     	 * Return an iterator over all registered DynClass.
+    	 *
     	 * @return the iterator.
     	 */
     	public Iterator interator();
         /**
          * Obtiene el la clase asociado al nombre indicado dentro del
          * namespace pedido.
+         *
          * @param name
          *            , nombre de la clase que queremos obtener.
          * @return la clase requerida.
          */
         public DynClass get(String namespace, String name);
     	/**
     	 * Return the list of names of all registered DynClass.
+    	 *
     	 * @return list of DynClass names.
     	 */
     	public List getNames();
         /**
          * Comprueba si esta registrada una clase.
+         *
          * @return true si la clase "name" esta registrada, false si no.
          */
         public boolean has(String name);
         /**
          * Comprueba si esta registrada una clase.
+         *
          * @return true si la clase "name" esta registrada, false si no.
          */
         public boolean has(String namespace, String name);
     	/**
     	 * Create a new DynObject associated to the DynStruct or DynClass
     	 * passed as parameter.
+    	 *
     	 * @param dynStruct or dynClass to use for create the dynObject
     	 * @return the new DynObject
     	 */
     	public DynObject createDynObject(DynStruct dynStruct);
         /**
          * Return the count of registered DynClass.
+         *
          * @return count of DynClass
          */
         public int getCount();
     	/**
     	 * Crea un nuevo objeto asociandole como clase base la indicada que tiene el
     	 * nombre indicado.
+    	 *
     	 * @param dynClassName
     	 * @return el nuevo DynObject
     	 */
     	public DynObject createDynObject(String classname);
         /**
          * Return an iterator over all registered DynClass.
+         *
          * @return the iterator.
          */
         public Iterator interator();

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

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

Revision 301