[wise-commits] wise SVN: r462 - in webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui: treeElement and 1 other directory.
wise-commits at lists.jboss.org
wise-commits at lists.jboss.org
Fri Jan 25 18:23:53 EST 2013
Author: alessio.soldano at jboss.com
Date: 2013-01-25 18:23:53 -0500 (Fri, 25 Jan 2013)
New Revision: 462
Added:
webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/LazyLoadWiseTreeElement.java
Modified:
webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/ClientConversationBean.java
webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElement.java
webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElementBuilder.java
Log:
WIP on lazy load elements (to deal with parameter type models including cycles)
Modified: webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/ClientConversationBean.java
===================================================================
--- webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/ClientConversationBean.java 2013-01-20 23:27:29 UTC (rev 461)
+++ webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/ClientConversationBean.java 2013-01-25 23:23:53 UTC (rev 462)
@@ -122,22 +122,22 @@
}
private static TreeNodeImpl convertOperationParametersToGui(WSMethod wsMethod, WSDynamicClient client) {
- WiseTreeElementBuilder builder = new WiseTreeElementBuilder();
+ WiseTreeElementBuilder builder = new WiseTreeElementBuilder(client);
TreeNodeImpl rootElement = new TreeNodeImpl();
Collection<? extends WebParameter> parameters = wsMethod.getWebParams().values();
for (WebParameter parameter : parameters) {
- WiseTreeElement wte = builder.buildTreeFromType(parameter.getType(), parameter.getName(), client);
+ WiseTreeElement wte = builder.buildTreeFromType(parameter.getType(), parameter.getName());
rootElement.addChild(wte.getId(), wte);
}
return rootElement;
}
private static TreeNodeImpl convertOperationResultToGui(InvocationResult result, WSDynamicClient client) {
- WiseTreeElementBuilder builder = new WiseTreeElementBuilder();
+ WiseTreeElementBuilder builder = new WiseTreeElementBuilder(client);
TreeNodeImpl rootElement = new TreeNodeImpl();
for (Entry<String, Object> res : result.getResult().entrySet()) {
Object resObj = res.getValue();
- WiseTreeElement wte = builder.buildTreeFromType(resObj.getClass(), res.getKey(), client, resObj);
+ WiseTreeElement wte = builder.buildTreeFromType(resObj.getClass(), res.getKey(), resObj);
rootElement.addChild(wte.getId(), wte);
}
return rootElement;
Added: webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/LazyLoadWiseTreeElement.java
===================================================================
--- webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/LazyLoadWiseTreeElement.java (rev 0)
+++ webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/LazyLoadWiseTreeElement.java 2013-01-25 23:23:53 UTC (rev 462)
@@ -0,0 +1,95 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2013, Red Hat, Inc. and/or its affiliates, and individual
+ * contributors by the @authors tag. See the copyright.txt in the
+ * distribution for a full listing of individual contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jboss.wise.gui.treeElement;
+
+import java.lang.reflect.Type;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.jboss.wise.core.utils.IDGenerator;
+
+/**
+ * This tree element is for storing lazy load references to other elements;
+ * required because in some uncommon scenario, the parameter trees might
+ * actually be graphs... (the actually passed data won't be a graph, but
+ * the type model can have cycles in it)
+ *
+ * @author Alessio Soldano, alessio.soldano at jboss.com
+ */
+public class LazyLoadWiseTreeElement extends WiseTreeElement {
+
+ private static final long serialVersionUID = 1L;
+
+ private boolean resolved = false;
+ protected Map<Type, WiseTreeElement> treeTypesMap;
+
+ private LazyLoadWiseTreeElement() {
+ this.kind = LAZY;
+ this.id = IDGenerator.nextVal();
+ }
+
+ public LazyLoadWiseTreeElement(Type classType, String name, Map<Type, WiseTreeElement> treeTypesMap) {
+ this.kind = LAZY;
+ this.id = IDGenerator.nextVal();
+ this.classType = classType;
+ this.nil = false;
+ this.name = name;
+ this.treeTypesMap = treeTypesMap;
+ }
+
+ public WiseTreeElement clone() {
+ LazyLoadWiseTreeElement element = new LazyLoadWiseTreeElement();
+ element.setName(this.name);
+ element.setNil(this.nil);
+ element.setClassType(this.classType);
+ element.setRemovable(this.isRemovable());
+ element.setNillable(this.isNillable());
+ element.setResolved(false); //copy into an unresolved element and do not copy child
+ element.setTreeTypesMap(this.treeTypesMap);
+ return element;
+ }
+
+ public void resolveReference() {
+ if (!isResolved()) {
+ WiseTreeElement ref = treeTypesMap.get(this.classType);
+ WiseTreeElement component = (WiseTreeElement) ref.clone();
+ addChild(component.getId(), component);
+ setResolved(true);
+ }
+ }
+
+ public Object toObject() {
+ Iterator<Object> keyIt = this.getChildrenKeysIterator();
+ return keyIt.hasNext() ? ((WiseTreeElement)this.getChild(keyIt.next())).toObject() : null;
+ }
+
+ public boolean isResolved() {
+ return resolved;
+ }
+
+ public void setResolved(boolean resolved) {
+ this.resolved = resolved;
+ }
+
+ public Map<Type, WiseTreeElement> getTreeTypesMap() {
+ return treeTypesMap;
+ }
+
+ public void setTreeTypesMap(Map<Type, WiseTreeElement> treeTypesMap) {
+ this.treeTypesMap = treeTypesMap;
+ }
+}
Modified: webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElement.java
===================================================================
--- webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElement.java 2013-01-20 23:27:29 UTC (rev 461)
+++ webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElement.java 2013-01-25 23:23:53 UTC (rev 462)
@@ -38,6 +38,7 @@
public static final String DURATION = "Duration";
public static final String ENUMERATION = "Enumeration";
public static final String GROUP = "group";
+ public static final String LAZY = "lazy";
public static final String PARAMETERIZED = "Parameterized";
public static final String QNAME = "qname";
public static final String ROOT = "root";
@@ -50,7 +51,7 @@
protected boolean nil; //whether this elements has the attribute xsi:nil set to "true"
protected boolean nillable = true; //for primitives and explicitly not nillable elements
private boolean removable = false; // to be used on array elements
-
+
protected Type classType;
protected WiseTreeElement() {
Modified: webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElementBuilder.java
===================================================================
--- webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElementBuilder.java 2013-01-20 23:27:29 UTC (rev 461)
+++ webgui/branches/cdi-jsf/src/main/java/org/jboss/wise/gui/treeElement/WiseTreeElementBuilder.java 2013-01-25 23:23:53 UTC (rev 462)
@@ -21,6 +21,10 @@
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlElement;
@@ -40,36 +44,56 @@
* @author alessio.soldano at jboss.com
*/
public class WiseTreeElementBuilder {
-
- public WiseTreeElement buildTreeFromType(Type type, String name, WSDynamicClient client) {
- return buildTreeFromType(type, name, client, null, null, null);
+
+ private WSDynamicClient client;
+
+ public WiseTreeElementBuilder(WSDynamicClient client) {
+ this.client = client;
}
- public WiseTreeElement buildTreeFromType(Type type, String name, WSDynamicClient client, Object obj) {
- return buildTreeFromType(type, name, client, obj, null, null);
+ public WiseTreeElement buildTreeFromType(Type type, String name) {
+ return buildTreeFromType(type, name, null, null, null, new HashMap<Type, WiseTreeElement>(), new HashSet<Type>());
}
+
+ public WiseTreeElement buildTreeFromType(Type type, String name, Object obj) {
+ return buildTreeFromType(type, name, obj, null, null, new HashMap<Type, WiseTreeElement>(), new HashSet<Type>());
+ }
- private WiseTreeElement buildTreeFromType(Type type, String name, WSDynamicClient client, Object obj, Class<?> scope, String namespace) {
+ private WiseTreeElement buildTreeFromType(Type type,
+ String name,
+ Object obj,
+ Class<?> scope,
+ String namespace,
+ Map<Type, WiseTreeElement> typeMap,
+ Set<Type> stack) {
Logger.getLogger(this.getClass()).debug("=> Converting parameter '" + name + "', type '" + type + "'");
if (type instanceof ParameterizedType) {
Logger.getLogger(this.getClass()).debug("Parameterized type...");
ParameterizedType pt = (ParameterizedType) type;
- return this.buildParameterizedType(pt, name, obj, client, scope, namespace);
+ return this.buildParameterizedType(pt, name, obj, scope, namespace, typeMap, stack);
} else {
Logger.getLogger(this.getClass()).debug("Not a parameterized type... casting to Class");
- return this.buildFromClass((Class<?>) type, name, obj, client);
+
+ return this.buildFromClass((Class<?>) type, name, obj, typeMap, stack);
}
}
@SuppressWarnings("rawtypes")
- private WiseTreeElement buildParameterizedType(ParameterizedType pt, String name, Object obj, WSDynamicClient client, Class<?> scope, String namespace) {
+ private WiseTreeElement buildParameterizedType(ParameterizedType pt,
+ String name,
+ Object obj,
+ Class<?> scope,
+ String namespace,
+ Map<Type, WiseTreeElement> typeMap,
+ Set<Type> stack) {
+ Type firstTypeArg = pt.getActualTypeArguments()[0];
if (Collection.class.isAssignableFrom((Class<?>) pt.getRawType())) {
- WiseTreeElement prototype = this.buildTreeFromType(pt.getActualTypeArguments()[0], name, client, null);
+ WiseTreeElement prototype = this.buildTreeFromType(firstTypeArg, name, null, null, null, typeMap, stack);
GroupWiseTreeElement group = new GroupWiseTreeElement(pt, name, prototype);
if (obj != null) {
for (Object o : (Collection) obj) {
- group.addChild(IDGenerator.nextVal(), this.buildTreeFromType(pt.getActualTypeArguments()[0], name, client, o));
+ group.addChild(IDGenerator.nextVal(), this.buildTreeFromType(firstTypeArg, name, o, null, null, typeMap, stack));
}
}
return group;
@@ -78,13 +102,17 @@
if (obj != null && obj instanceof JAXBElement) {
obj = ((JAXBElement)obj).getValue();
}
- WiseTreeElement element = this.buildTreeFromType(pt.getActualTypeArguments()[0], name, client, obj);
+ WiseTreeElement element = this.buildTreeFromType(firstTypeArg, name, obj, null, null, typeMap, stack);
parameterized.addChild(element.getId(), element);
return parameterized;
}
}
- private WiseTreeElement buildFromClass(Class<?> cl, String name, Object obj, WSDynamicClient client) {
+ private WiseTreeElement buildFromClass(Class<?> cl,
+ String name,
+ Object obj,
+ Map<Type, WiseTreeElement> typeMap,
+ Set<Type> stack) {
if (cl.isArray()) {
Logger.getLogger(this.getClass()).debug("* array");
@@ -92,15 +120,21 @@
throw new WiseRuntimeException("Converter doesn't support this Object[] yet.");
}
- if (cl.isEnum() || cl.isPrimitive() || client.getClassLoader() != cl.getClassLoader()) {
+ if (isSimpleType(cl, client)) {
Logger.getLogger(this.getClass()).debug("* simple");
SimpleWiseTreeElement element = SimpleWiseTreeElementFactory.create(cl, name);
element.parseObject(obj);
return element;
} else { // complex
+ if (stack.contains(cl)) {
+ Logger.getLogger(this.getClass()).debug("* lazy");
+ return new LazyLoadWiseTreeElement(cl, name, typeMap);
+ }
+
Logger.getLogger(this.getClass()).debug("* complex");
+
ComplexWiseTreeElement complex = new ComplexWiseTreeElement(cl, name);
-
+ stack.add(cl);
for (Field field : ReflectionUtils.getAllFields(cl)) {
XmlElement elemAnnotation = field.getAnnotation(XmlElement.class);
XmlElementRef refAnnotation = field.getAnnotation(XmlElementRef.class);
@@ -126,10 +160,16 @@
throw new WiseRuntimeException("Error calling getter method for field " + field, e);
}
}
- WiseTreeElement element = this.buildTreeFromType(field.getGenericType(), fieldName, client, fieldValue, cl, namespace);
+ WiseTreeElement element = this.buildTreeFromType(field.getGenericType(), fieldName, fieldValue, cl, namespace, typeMap, stack);
complex.addChild(element.getId(), element);
}
+ stack.remove(cl);
+ typeMap.put(cl, complex);
return complex;
}
}
+
+ private static boolean isSimpleType(Class<?> cl, WSDynamicClient client) {
+ return cl.isEnum() || cl.isPrimitive() || client.getClassLoader() != cl.getClassLoader();
+ }
}
More information about the wise-commits
mailing list