User: mulder
Date: 00/07/03 17:10:04
Added: src/main/org/jboss/metadata/aggregate AggregateBean.java
AggregateContainer.java AggregateField.java
AggregateMetaData.java AggregateMethod.java
AggregateServer.java
Log:
Added new metadata classes to CVS. Currently read-only (reads XML files
written by EJX). We plan to add GUI and write support for EJX.
Revision Changes Path
1.1 jboss/src/main/org/jboss/metadata/aggregate/AggregateBean.java
Index: AggregateBean.java
===================================================================
package org.jboss.metadata.aggregate;
import java.lang.reflect.*;
import java.util.*;
import org.jboss.metadata.*;
public class AggregateBean extends AggregateMetaData implements BeanMetaData {
private AggregateContainer container;
private AggregateMethod[] methods;
private AggregateMethod[] homeMethods;
private AggregateField[] fields;
private String name;
public AggregateBean(String name) {
this.name = name;
methods = homeMethods = new AggregateMethod[0];
container = new AggregateContainer();
fields = new AggregateField[0];
}
public AggregateBean(String name, BeanMetaData[] plugins) {
this(name);
for(int i=0; i<plugins.length; i++)
addPlugin(plugins[i]);
}
public void addPlugin(BeanMetaData plugin) {
super.addPlugin(plugin);
methods = mergeMethods(plugin.getMethods(), methods, plugin.getManager());
homeMethods = mergeMethods(plugin.getHomeMethods(), homeMethods,
plugin.getManager());
fields = mergeFields(plugin.getFields(), fields, plugin.getManager());
container.addPlugin(plugin.getContainer());
}
private static MethodMetaData getMethod(Set source, String name, Class[] args) {
Iterator it = source.iterator();
while(it.hasNext()) {
MethodMetaData mmd = (MethodMetaData)it.next();
if(mmd.getName().equals(name) &&
paramsMatch(mmd.getParameterTypes(), args))
return mmd;
}
throw new IllegalArgumentException();
}
private static FieldMetaData getField(Set source, String name) {
Iterator it = source.iterator();
while(it.hasNext()) {
FieldMetaData fmd = (FieldMetaData)it.next();
if(fmd.getName().equals(name))
return fmd;
}
throw new IllegalArgumentException();
}
private static AggregateMethod[] mergeMethods(Set incoming, AggregateMethod[]
existing, MetaDataPlugin manager) {
for(int i=0; i<existing.length; i++) {
String name = existing[i].getName();
Class[] args = existing[i].getParameterTypes();
try {
MethodMetaData mmd = getMethod(incoming, name, args);
existing[i].addPlugin(mmd);
incoming.remove(mmd);
} catch(IllegalArgumentException e) {
try {
Class cls = manager.getMethodClass();
Object instance = cls.newInstance();
Method m = cls.getMethod("setName", new Class[]{String.class});
m.invoke(instance, new Object[]{name});
m = cls.getMethod("setParameterTypes", new
Class[]{Class[].class});
m.invoke(instance, new Object[]{args});
existing[i].addPlugin((MethodMetaData)instance);
} catch(Exception e2) {e2.printStackTrace();}
}
}
Vector v = new Vector(Arrays.asList(existing));
for(Iterator it = incoming.iterator(); it.hasNext();) {
MethodMetaData mmd = (MethodMetaData)it.next();
String name = mmd.getName();
Class[] args = mmd.getParameterTypes();
MethodMetaData[] list = new
MethodMetaData[MetaDataFactory.getPluginCount()];
for(int i=0; i<list.length; i++) {
Class cls = MetaDataFactory.getPlugin(i).getMethodClass();
if(cls.equals(mmd.getClass()))
list[i] = mmd;
else
try {
list[i] = (MethodMetaData)cls.newInstance();
Method m = cls.getMethod("setName", new
Class[]{String.class});
m.invoke(list[i], new Object[]{name});
m = cls.getMethod("setParameterTypes", new
Class[]{Class[].class});
m.invoke(list[i], new Object[]{args});
} catch(Exception e) {e.printStackTrace();}
}
v.addElement(new AggregateMethod(name, args, list));
}
if(v.size() > existing.length)
return (AggregateMethod[])v.toArray(new AggregateMethod[v.size()]);
else
return existing;
}
private static AggregateField[] mergeFields(Set incoming, AggregateField[]
existing, MetaDataPlugin manager) {
for(int i=0; i<existing.length; i++) {
String name = existing[i].getName();
try {
FieldMetaData fmd = getField(incoming, name);
existing[i].addPlugin(fmd);
incoming.remove(fmd);
} catch(IllegalArgumentException e) {
try {
Class cls = manager.getFieldClass();
Object instance = cls.newInstance();
Method m = cls.getMethod("setName", new Class[]{String.class});
m.invoke(instance, new Object[]{name});
existing[i].addPlugin((FieldMetaData)instance);
} catch(Exception e2) {e2.printStackTrace();}
}
}
Vector v = new Vector(Arrays.asList(existing));
for(Iterator it = incoming.iterator(); it.hasNext();) {
FieldMetaData fmd = (FieldMetaData)it.next();
String name = fmd.getName();
FieldMetaData[] list = new
FieldMetaData[MetaDataFactory.getPluginCount()];
for(int i=0; i<list.length; i++) {
Class cls = MetaDataFactory.getPlugin(i).getFieldClass();
if(cls.equals(fmd.getClass()))
list[i] = fmd;
else
try {
list[i] = (FieldMetaData)cls.newInstance();
Method m = cls.getMethod("setName", new
Class[]{String.class});
m.invoke(list[i], new Object[]{name});
} catch(Exception e) {e.printStackTrace();}
}
v.addElement(new AggregateField(name, list));
}
if(v.size() > existing.length)
return (AggregateField[])v.toArray(new AggregateField[v.size()]);
else
return existing;
}
public MethodMetaData getMethod(String name, Class[] args) {
for(int i=0; i<methods.length; i++)
if(methods[i].getName().equals(name) &&
paramsMatch(methods[i].getParameterTypes(), args))
return methods[i];
throw new IllegalArgumentException("Method not found");
}
public MethodMetaData getHomeMethod(String name, Class[] args) {
for(int i=0; i<homeMethods.length; i++)
if(homeMethods[i].getName().equals(name) &&
paramsMatch(homeMethods[i].getParameterTypes(), args))
return methods[i];
throw new IllegalArgumentException("Method not found");
}
public FieldMetaData getField(String name) {
for(int i=0; i<fields.length; i++)
if(fields[i].getName().equals(name))
return fields[i];
throw new IllegalArgumentException("Field not found");
}
public Set getMethods() {
return new HashSet(Arrays.asList(methods));
}
public Set getHomeMethods() {
return new HashSet(Arrays.asList(homeMethods));
}
public Set getFields() {
return new HashSet(Arrays.asList(fields));
}
public String getName() {
return name;
}
public ContainerMetaData getContainer() {
return container;
}
private static boolean paramsMatch(Class[] one, Class[] two) {
if(one.length != two.length)
return false;
for(int i=0; i<one.length; i++)
if(!one[i].equals(two[i]))
return false;
return true;
}
}
1.1
jboss/src/main/org/jboss/metadata/aggregate/AggregateContainer.java
Index: AggregateContainer.java
===================================================================
package org.jboss.metadata.aggregate;
import org.jboss.metadata.*;
import java.util.*;
public class AggregateContainer extends AggregateMetaData implements
ContainerMetaData {
public AggregateContainer() {
super();
}
public AggregateContainer(ContainerMetaData[] plugins) {
super(plugins);
}
}
1.1 jboss/src/main/org/jboss/metadata/aggregate/AggregateField.java
Index: AggregateField.java
===================================================================
package org.jboss.metadata.aggregate;
import org.jboss.metadata.*;
public class AggregateField extends AggregateMetaData implements FieldMetaData {
private String name;
public AggregateField(String name) {
this.name = name;
}
public AggregateField(String name, FieldMetaData[] plugins) {
super(plugins);
this.name = name;
}
public void addPlugin(FieldMetaData plugin) {
super.addPlugin(plugin);
}
public String getName() {
return name;
}
}
1.1
jboss/src/main/org/jboss/metadata/aggregate/AggregateMetaData.java
Index: AggregateMetaData.java
===================================================================
package org.jboss.metadata.aggregate;
import org.jboss.metadata.*;
import java.util.*;
public class AggregateMetaData implements MetaData {
MetaData[] plugins;
public AggregateMetaData() {
plugins = new MetaData[0];
}
public AggregateMetaData(MetaData[] plugins) {
this.plugins = plugins;
validate();
}
protected void addPlugin(MetaData plugin) {
for(int i=0; i<plugins.length; i++) {
if(plugins[i].getManager().equals(plugin.getManager())) {
plugins[i] = plugin;
return;
}
}
LinkedList list = new LinkedList(Arrays.asList(plugins));
list.add(plugin);
plugins = (MetaData[])list.toArray(new MetaData[list.size()]);
validate();
}
public boolean hasProperty(String name) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].hasProperty(name))
return true;
return false;
}
public Object getProperty(String name) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].hasProperty(name))
return plugins[i].getProperty(name);
throw new IllegalArgumentException("No such property '"+name+"'");
}
public void setProperty(String name, Object value) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].hasProperty(name)) {
plugins[i].setProperty(name, value);
return;
}
throw new IllegalArgumentException("No such property '"+name+"'");
}
public String[] getPropertyNames() {
String[][] names = new String[plugins.length][];
int total = 0;
for(int i=0; i<plugins.length; i++) {
names[i] = plugins[i].getPropertyNames();
total += names[i].length;
}
String[] result = new String[total];
total = 0;
for(int i=0; i<names.length; i++)
for(int j=0; j<names[i].length; j++)
result[total++] = names[i][j];
return result;
}
public MetaDataPlugin getManager() {
return null;
}
public void clear() {
for(int i=0; i<plugins.length; i++)
plugins[i].clear();
}
public boolean containsKey(Object key) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].containsKey(key))
return true;
return false;
}
public boolean containsValue(Object value) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].containsValue(value))
return true;
return false;
}
public Set entrySet() {
HashSet set = new HashSet();
for(int i=0; i<plugins.length; i++)
set.addAll(plugins[i].entrySet());
return set;
}
public Object get(Object key) {
return getProperty((String)key);
}
public boolean isEmpty() {
return plugins.length > 0;
}
public Set keySet() {
HashSet set = new HashSet();
for(int i=0; i<plugins.length; i++)
set.addAll(plugins[i].keySet());
return set;
}
public Object put(Object key, Object value) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].containsKey(key))
return plugins[i].put(key, value);
throw new IllegalArgumentException("No such property '"+key+"'");
}
public void putAll(Map stuff) {
Iterator it = stuff.keySet().iterator();
while(it.hasNext()) {
Object key = it.next();
setProperty((String)key, stuff.get(key));
}
}
public Object remove(Object key) {
for(int i=0; i<plugins.length; i++)
if(plugins[i].containsKey(key))
return plugins[i].remove(key);
throw new IllegalArgumentException("No such property '"+key+"'");
}
public int size() {
int total = 0;
for(int i=0; i<plugins.length; i++)
total += plugins[i].size();
return total;
}
public Collection values() {
return new AbstractCollection() {
public int size() {
return AggregateMetaData.this.size();
}
public Iterator iterator() {
return new AggregateIterator();
}
};
}
private void validate() {
HashSet set = new HashSet();
for(int i=0; i<plugins.length; i++) {
String[] names = plugins[i].getPropertyNames();
for(int j=0; j<names.length; j++)
if(!set.add(names[j]))
throw new IllegalArgumentException("Found two properties named
'"+names[j]+"'!");
}
}
class AggregateIterator implements Iterator {
int pos = 0;
Iterator current;
public boolean hasNext() {
while((current == null || !current.hasNext())
&& pos < plugins.length)
current = plugins[pos++].values().iterator();
return current != null && current.hasNext();
}
public Object next() {
if(current == null || !current.hasNext()) hasNext();
if(current == null) throw new NoSuchElementException();
return current.next();
}
public void remove() {
if(current != null)
current.remove();
else throw new IllegalStateException();
}
}
}
1.1 jboss/src/main/org/jboss/metadata/aggregate/AggregateMethod.java
Index: AggregateMethod.java
===================================================================
package org.jboss.metadata.aggregate;
import org.jboss.metadata.*;
import java.util.*;
public class AggregateMethod extends AggregateMetaData implements MethodMetaData {
private String name;
private Class[] params;
public AggregateMethod(String name, Class[] paramTypes) {
this.name = name;
params = paramTypes;
}
public AggregateMethod(String name, Class[] paramTypes, MethodMetaData[]
plugins) {
super(plugins);
this.name = name;
params = paramTypes;
}
public void addPlugin(MethodMetaData plugin) {
super.addPlugin(plugin);
}
public String getName() {
return name;
}
public Class[] getParameterTypes() {
return params;
}
}
1.1 jboss/src/main/org/jboss/metadata/aggregate/AggregateServer.java
Index: AggregateServer.java
===================================================================
package org.jboss.metadata.aggregate;
import java.lang.reflect.*;
import java.util.*;
import org.jboss.metadata.*;
public class AggregateServer extends AggregateMetaData implements ServerMetaData {
private AggregateBean[] beans;
public AggregateServer() {
super();
beans = new AggregateBean[0];
}
public AggregateServer(ServerMetaData[] plugins) {
this();
for(int i=0; i<plugins.length; i++)
addPlugin(plugins[i]);
}
public void addPlugin(ServerMetaData plugin) {
super.addPlugin(plugin);
Set incoming = plugin.getBeans();
for(int i=0; i<beans.length; i++) {
String name = beans[i].getName();
try {
BeanMetaData bmd = plugin.getBean(name);
beans[i].addPlugin(bmd);
incoming.remove(bmd);
} catch(IllegalArgumentException e) {
try {
Class cls = plugin.getManager().getBeanClass();
Object instance = cls.getConstructor(new
Class[]{String.class}).newInstance(new Object[]{name});
beans[i].addPlugin((BeanMetaData)instance);
} catch(Exception e2) {e.printStackTrace();}
}
}
Vector v = new Vector(Arrays.asList(beans));
for(Iterator it = incoming.iterator(); it.hasNext();) {
BeanMetaData bmd = (BeanMetaData)it.next();
String name = bmd.getName();
BeanMetaData[] list = new BeanMetaData[MetaDataFactory.getPluginCount()];
for(int i=0; i<list.length; i++) {
Class cls = MetaDataFactory.getPlugin(i).getBeanClass();
if(cls.equals(bmd.getClass()))
list[i] = bmd;
else
try {
list[i] = (BeanMetaData)cls.newInstance();
Method m = cls.getMethod("setName", new
Class[]{String.class});
m.invoke(list[i], new Object[]{name});
} catch(Exception e) {e.printStackTrace();}
}
v.addElement(new AggregateBean(name, list));
}
if(v.size() > beans.length)
beans = (AggregateBean[])v.toArray(new AggregateBean[v.size()]);
}
public BeanMetaData getBean(String name) {
for(int i=0; i<beans.length; i++)
if(beans[i].getName().equals(name))
return beans[i];
throw new IllegalArgumentException("Can't find bean '"+name+"'");
}
public Set getBeans() {
return new HashSet(Arrays.asList(beans));
}
}
