diff options
Diffstat (limited to 'sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout')
6 files changed, 1906 insertions, 0 deletions
diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/ComponentEntity.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/ComponentEntity.java new file mode 100755 index 0000000000..50da28ec67 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/ComponentEntity.java @@ -0,0 +1,223 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.tuscany.sca.diagram.artifacts.Constant; + +/** + * Represents an unit (a component including its references, services, properties + * and adjacent units) in the diagram. + * + */ +public class ComponentEntity extends Entity { + + private Map<String, String> referenceToServiceMap = new HashMap<String, String>(); + + public ComponentEntity() { + setStartPosition(200); + setHeight(Constant.COMPONENT_DEFAULT_HEIGHT); + setWidth(Constant.COMPONENT_DEFAULT_WIDTH); + + setRefHeight(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPONENT_OF_REFERENCE); + setSerHeight(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPONENT_OF_SERVICE); + setPropWidth(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPONENT_OF_PROPERTY); + } + + public void build() { + // Find the services height + int size1 = services.size(); + int total1 = size1 * serHeight + (size1 + 1) * Constant.SPACING_FOR_COMPONENT_OF_SERVICE; + + // Find the references height + int size2 = references.size(); + int total2 = size2 * refHeight + (size2 + 1) * Constant.SPACING_FOR_COMPONENT_OF_REFERENCE; + + int total = Math.max(total1, total2); + height = Math.max(total, height); + + // Find the properties width + int size3 = properties.size(); + int total3 = size3 * propWidth + (size3 + 1) * Constant.SPACING_FOR_COMPONENT_OF_PROPERTY; + + width = Math.max(width, total3); + + } + + /** + * Put a value to referenceToServiceMap + * @param ref + * @param ser + * @return successfully added or not + */ + //assumption there can not be two services for the same reference + public boolean addToRefToSerMap(String ref, String ser) { + //ref = ref.toLowerCase(); + //ser = ser.toLowerCase(); + + if (referenceToServiceMap.containsKey(ref)) + return false; + + referenceToServiceMap.put(ref, ser); + return true; + } + + /** + * Retrieve a service name for a given reference + * @param ref + * @return service name + */ + public String getSerOfRef(String ref) { + //ref = ref.toLowerCase(); + + if (!referenceToServiceMap.containsKey(ref)) + return null; + + return referenceToServiceMap.get(ref); + } + + public Map<String, String> getReferenceToServiceMap() { + return referenceToServiceMap; + } + + public void setReferenceToServiceMap(HashMap<String, String> referenceToServiceMap) { + this.referenceToServiceMap = referenceToServiceMap; + } + + // public int getNoOfRefs(){ + // return references.size(); + // } + // + // public int getNoOfSers(){ + // return services.size(); + // } + // + // public int getNoOfProps(){ + // return properties.size(); + // } + // + // public int getNoOfAdjacentUnits(){ + // return adjacentEntities.size(); + // } + // + // /** + // * Put a value to referenceToServiceMap + // * @param ref + // * @param ser + // * @return successfully added or not + // */ + // //assumption there can not be two services for the same reference + // public boolean addToRefToSerMap(String ref, String ser){ + // //ref = ref.toLowerCase(); + // //ser = ser.toLowerCase(); + // + // if (referenceToServiceMap.containsKey(ref)) + // return false; + // + // referenceToServiceMap.put(ref, ser); + // return true; + // } + // + // /** + // * Retrieve a service name for a given reference + // * @param ref + // * @return service name + // */ + // public String getSerOfRef(String ref){ + // //ref = ref.toLowerCase(); + // + // if (!referenceToServiceMap.containsKey(ref)) + // return null; + // + // return referenceToServiceMap.get(ref); + // } + // + // public void addAService(String serName){ + // //serName = serName.toLowerCase(); + // services.add(serName); + // + // } + // + // public void addAReference(String refName){ + // //refName = refName.toLowerCase(); + // references.add(refName); + // + // } + // + // public void addAProperty(String propName){ + // //propName = propName.toLowerCase(); + // properties.add(propName); + // + // } + // + // public void addAnAdjacentEntity(String x){ + //// System.out.println("eee "+x); + // adjacentEntities.add(x); + // + // } + // + // public void addAnConnectedEntity(String x){ + //// System.out.println("eee "+x); + // adjacentEntities.add(x); + // + // } + // + // public HashMap<String, String> getReferenceToServiceMap() { + // return referenceToServiceMap; + // } + // public void setReferenceToServiceMap( + // HashMap<String, String> referenceToServiceMap) { + // this.referenceToServiceMap = referenceToServiceMap; + // } + // public ArrayList<String> getProperties() { + // return properties; + // } + // public void setProperties(ArrayList<String> properties) { + // this.properties = properties; + // } + // public HashSet<String> getAdjacentEntities() { + // return adjacentEntities; + // } + // public void setAdjacentEntities(HashSet<String> adjacentEntities) { + // this.adjacentEntities = adjacentEntities; + // } + // public void setServices(ArrayList<String> services) { + // this.services = services; + // } + // + // public ArrayList<String> getServices() { + // return services; + // } + // + // public ArrayList<String> getReferences() { + // return references; + // } + + // public void setConnectedEntities(HashSet<String> connectedEntities) { + // this.connectedEntities = connectedEntities; + // } + // + // public HashSet<String> getConnectedEntities() { + // return connectedEntities; + // } + +} diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/CompositeEntity.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/CompositeEntity.java new file mode 100755 index 0000000000..1520b0ae83 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/CompositeEntity.java @@ -0,0 +1,182 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.apache.tuscany.sca.diagram.artifacts.Constant; + +/** + * Represents an unit (a component including its references, services, properties + * and adjacent units) in the diagram. + * + */ +public class CompositeEntity extends Entity { + + // private String componentName; + // private int X, Y, level=-1, lane=-1, refHeight, serHeight, propLength; + // private final int height= Component.DEFAULT_HEIGHT, width= Component.DEFAULT_WIDTH; + // public static final int defaultNoOfSers= Component.DEFAULT_HEIGHT / (Service.MAXIMUM_HEIGHT+Service.SPACING); + // public static final int defaultNoOfRefs= Component.DEFAULT_HEIGHT / (Reference.MAXIMUM_HEIGHT+Reference.SPACING); //same value for defaultNoOfSers + // public static final int defaultNoOfProps= Component.DEFAULT_WIDTH / (Property.MAXIMUM_HEIGHT+Property.SPACING); + + private final String fileNameSuffix = "_diagram"; + private int maxInternalLevel = -1; + private int maxInternalLane = -1; + private ComponentEntity[] componentList; + private int[][] connections; + private HashMap<String, String> promoteAService = new HashMap<String, String>(); + private HashMap<String, ArrayList<String>> promoteAReference = new HashMap<String, ArrayList<String>>(); + private ArrayList<String> includedComposites = new ArrayList<String>(); + + //private HashSet<String> connectedEntities = new HashSet<String>(); + + public CompositeEntity(String name) { + setStartPosition(200); + setLevel(0); + setLane(0); + + setX(getStartPosition()); + setY(getStartPosition() / 2); + + setName(name); + + setRefHeight(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPOSITE_OF_REFERENCE); + setSerHeight(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPOSITE_OF_SERVICE); + setPropWidth(Constant.DEFAULT_MAXIMUM_HEIGHT_FOR_COMPOSITE_OF_PROPERTY); + } + + public void build() { + int h = height; + int w = width; + + // Find the services height + int size1 = services.size(); + int total1 = size1 * serHeight + (size1 + 1) * Constant.SPACING_FOR_COMPOSITE_OF_SERVICE; + + // Find the references height + int size2 = references.size(); + int total2 = size2 * refHeight + (size2 + 1) * Constant.SPACING_FOR_COMPOSITE_OF_REFERENCE; + + int total = Math.max(total1, total2); + + if (!includedComposites.isEmpty()) { + height = Math.max(total, h) + 80 + getY(); + } else { + height = Math.max(total, h) + getY(); + } + + // Find the properties width + int size3 = properties.size(); + int total3 = size3 * propWidth + (size3 + 1) * Constant.SPACING_FOR_COMPOSITE_OF_PROPERTY; + + width = Math.max(w, total3) + getX(); + } + + public int getMaxInternalLevel() { + return maxInternalLevel; + } + + public int getMaxInternalLane() { + return maxInternalLane; + } + + public boolean addToPromoteAService(String compositeSer, String componentSer) { + //ref = ref.toLowerCase(); + //ser = ser.toLowerCase(); + + if (promoteAService.containsKey(compositeSer)) + return false; + + promoteAService.put(compositeSer, componentSer); + return true; + } + + public void setPromoteAService(HashMap<String, String> promoteAService) { + this.promoteAService = promoteAService; + } + + public HashMap<String, String> getPromoteAService() { + return promoteAService; + } + + public boolean addToPromoteAReference(String compositeRef, String componentRef) { + ArrayList<String> list; + + if (promoteAReference.containsKey(compositeRef)) { + list = promoteAReference.get(compositeRef); + } else { + list = new ArrayList<String>(); + } + + list.add(componentRef); + promoteAReference.put(compositeRef, list); + return true; + } + + public boolean addToIncludedComposites(String composite) { + + includedComposites.add(composite); + + return true; + } + + public void setPromoteAReference(HashMap<String, ArrayList<String>> promoteAReference) { + this.promoteAReference = promoteAReference; + } + + public HashMap<String, ArrayList<String>> getPromoteAReference() { + return promoteAReference; + } + + public ComponentEntity[] getComponentList() { + return componentList; + } + + public void setComponentList(ComponentEntity[] componentList) { + this.componentList = componentList; + } + + public void setConnections(int[][] connections) { + this.connections = connections; + } + + public int[][] getConnections() { + return connections; + } + + public ArrayList<String> getIncludedComposites() { + return includedComposites; + } + + public String getFileNameSuffix() { + return fileNameSuffix; + } + + public void setMaxInternalLevel(int maxInternalLevel) { + this.maxInternalLevel = maxInternalLevel; + } + + public void setMaxInternalLane(int maxInternalLane) { + this.maxInternalLane = maxInternalLane; + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/Entity.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/Entity.java new file mode 100755 index 0000000000..cd9f1b8133 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/Entity.java @@ -0,0 +1,265 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import java.util.ArrayList; +import java.util.HashSet; + +public abstract class Entity { + protected int id = -1; //a unique integer id (0..n) + protected String name; // a unique name + protected int spaceFactor = 2; //which determines the free space surrounded by this + protected int x; // x coordinate + protected int y; // y coordinate + protected int level = -1; // corresponding row which this entity is placed + protected int lane = -1; // corresponding column which this entity is placed + protected boolean positionSet = false; + protected int height; // height of the entity + protected int width; // width of the entity + protected int refHeight; // height of a reference element + protected int serHeight; // height of a service element + protected int propWidth; // length of a property element + + protected int startPosition = 0; + protected Entity parent = null; + + protected ArrayList<String> references = new ArrayList<String>(); + + protected ArrayList<String> services = new ArrayList<String>(); + + protected ArrayList<String> properties = new ArrayList<String>(); + + protected HashSet<String> adjacentEntities = new HashSet<String>(); + + protected String implementation; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getX() { + return x; + } + + public void setX(int x) { + this.x = x; + } + + public int getY() { + return y; + } + + public void setY(int y) { + this.y = y; + } + + public int getLevel() { + return level; + } + + public void setLevel(int level) { + this.level = level; + } + + public int getLane() { + return lane; + } + + public void setLane(int lane) { + this.lane = lane; + } + + public int getHeight() { + return height; + } + + public void setHeight(int height) { + this.height = height; + } + + public int getWidth() { + return width; + } + + public void setWidth(int width) { + this.width = width; + } + + public int getRefHeight() { + return refHeight; + } + + public void setRefHeight(int refHeight) { + this.refHeight = refHeight; + } + + public int getSerHeight() { + return serHeight; + } + + public void setSerHeight(int serHeight) { + this.serHeight = serHeight; + } + + public int getPropWidth() { + return propWidth; + } + + public void setPropWidth(int propLength) { + this.propWidth = propLength; + } + + public int getNoOfRefs() { + return references.size(); + } + + public int getNoOfSers() { + return services.size(); + } + + public int getNoOfProps() { + return properties.size(); + } + + public int getNoOfAdjacentUnits() { + return adjacentEntities.size(); + } + + public void addAService(String serName) { + //serName = serName.toLowerCase(); + services.add(serName); + + } + + public void addAReference(String refName) { + //refName = refName.toLowerCase(); + references.add(refName); + + } + + public void addAProperty(String propName) { + //propName = propName.toLowerCase(); + properties.add(propName); + + } + + public void addAnAdjacentEntity(String x) { + // System.out.println("eee "+x); + adjacentEntities.add(x); + + } + + public void addAnConnectedEntity(String x) { + // System.out.println("eee "+x); + adjacentEntities.add(x); + + } + + public ArrayList<String> getProperties() { + return properties; + } + + public void setProperties(ArrayList<String> properties) { + this.properties = properties; + } + + public HashSet<String> getAdjacentEntities() { + return adjacentEntities; + } + + public void setAdjacentEntities(HashSet<String> adjacentEntities) { + this.adjacentEntities = adjacentEntities; + } + + public void setServices(ArrayList<String> services) { + this.services = services; + } + + public ArrayList<String> getServices() { + return services; + } + + public ArrayList<String> getReferences() { + return references; + } + + public void setId(int id) { + this.id = id; + } + + public int getId() { + return id; + } + + public void setPositionSet(boolean isPositionSet) { + this.positionSet = isPositionSet; + } + + public boolean isPositionSet() { + return positionSet; + } + + public int getSpaceFactor() { + return spaceFactor; + } + + public void setSpaceFactor(int spaceFactor) { + this.spaceFactor = spaceFactor; + } + + public void setStartPosition(int startPosition) { + this.startPosition = startPosition; + } + + public int getStartPosition() { + return startPosition; + } + + public void setParent(Entity parent) { + this.parent = parent; + } + + public Entity getParent() { + return parent; + } + + public String getImplementation() { + return implementation; + } + + public void setImplementation(String implementation) { + this.implementation = implementation; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("Entity [id=").append(id).append(", name=").append(name).append("]"); + return builder.toString(); + } + + /** + * Adjust the items and coordinates + */ + public abstract void build(); +} diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/EntityBuilder.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/EntityBuilder.java new file mode 100755 index 0000000000..485ced717d --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/EntityBuilder.java @@ -0,0 +1,562 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import org.apache.tuscany.sca.diagram.artifacts.Constant; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NodeList; + +public class EntityBuilder { + + private Document dom; + + private int totalWidth = 0; + private int totalHeight = 0; + + private CompositeEntity composite = null; + + /** + * Constructor which initiates the DOM document + * @param aDom DOM document + */ + public EntityBuilder(Document aDom) { + dom = aDom; + } + + public CompositeEntity buildCompositeEntity() { + + //get the root element + Element docEle = dom.getDocumentElement(); + + String compositeName; + compositeName = docEle.getAttribute("name"); + //System.out.println("compositeName "+compositeName); + + ComponentEntity[] comps = buildComponentEntities(docEle); + + composite = new CompositeEntity(compositeName); + + setParent(comps); + + //System.out.println("ComponentEntity "+comps[0].getLevel()); + int[][] conns = buildConnectionMatrix(comps); + + composite.setComponentList(comps); + composite.setConnections(conns); + + LayoutBuilder buildLayout = new LayoutBuilder(comps, conns, Constant.MAX_LEVELS); + buildLayout.placeEntities(); + composite.setHeight(buildLayout.getTotalHeight()); + composite.setWidth(buildLayout.getTotalWidth()); + composite.setMaxInternalLane(buildLayout.getTotalLane()); + composite.setMaxInternalLevel(buildLayout.getTotalLevel()); + + //System.out.println("conns "+conns[0][0]); + + buildCompositeService(docEle); + buildCompositeReference(docEle); + buildCompositeProperty(docEle); + + addInclusions(docEle); + + composite.build(); + + return composite; + } + + // private void assignCoordinates() { + // + // for(Entity ent: elts){ + // ent.setX(ent.getParent().getX() + ent.getStartPosition()); + // ent.setY(ent.getParent().getY() + ent.getStartPosition()/2); + // } + // } + + private void setParent(ComponentEntity[] comps) { + + for (ComponentEntity comp : comps) { + comp.setParent(composite); + } + } + + private void buildCompositeService(Element docEle) { + + NodeList nl = docEle.getElementsByTagName("service"); + //System.err.println("^^^^^^^^^ "+nl.getLength()); + if (nl != null && nl.getLength() > 0) { + + for (int i = 0; i < nl.getLength(); i++) { + + Element elt = (Element)nl.item(i); + + if (elt.getParentNode().getNodeName().equals("composite")) { + String compositeSer = elt.getAttribute("name"); + composite.addAService(compositeSer); + + String target = elt.getAttribute("promote"); + + String service, serviceComp; + String[] arr1 = extractComp(target); + serviceComp = arr1[0]; + service = arr1[1]; + + if (service == null) { + composite.addToPromoteAService(compositeSer, serviceComp); + } else { + composite.addToPromoteAService(compositeSer, serviceComp + "/" + service); + } + } + + } + } + } + + private void buildCompositeReference(Element docEle) { + + NodeList nl = docEle.getElementsByTagName("reference"); + //System.out.println("^^^^^^^^^ "+nl.getLength()); + if (nl != null && nl.getLength() > 0) { + + for (int i = 0; i < nl.getLength(); i++) { + + Element elt = (Element)nl.item(i); + + if (elt.getParentNode().getNodeName().equals("composite")) { + String compositeRef = elt.getAttribute("name"); + composite.addAReference(compositeRef); + + String targetStr = elt.getAttribute("promote"); + + String[] targets = targetStr.split(" "); + + for (String target : targets) { + + String reference, referenceComp; + String[] arr1 = extractComp(target); + referenceComp = arr1[0]; + reference = arr1[1]; + + if (reference == null) { + composite.addToPromoteAReference(compositeRef, referenceComp); + } else { + composite.addToPromoteAReference(compositeRef, referenceComp + "/" + reference); + } + } + + } + } + } + } + + private void buildCompositeProperty(Element docEle) { + + NodeList nl = docEle.getElementsByTagName("property"); + //System.out.println("^^^^^^^^^ "+nl.getLength()); + if (nl != null && nl.getLength() > 0) { + + for (int i = 0; i < nl.getLength(); i++) { + + Element elt = (Element)nl.item(i); + + if (elt.getParentNode().getNodeName().equals("composite")) { + String compositeProp = elt.getAttribute("name"); + composite.addAProperty(compositeProp); + } + } + } + } + + private void addInclusions(Element docEle) { + + NodeList nl = docEle.getElementsByTagName("include"); + //System.out.println("^^^^^^^^^ "+nl.getLength()); + if (nl != null && nl.getLength() > 0) { + + for (int i = 0; i < nl.getLength(); i++) { + + Element elt = (Element)nl.item(i); + + if (elt.getParentNode().getNodeName().equals("composite")) { + String compToBeIncluded = elt.getAttribute("name"); + composite.addToIncludedComposites(compToBeIncluded); + } + } + } + } + + private int[][] buildConnectionMatrix(ComponentEntity[] comps) { + + int[][] connections = new int[comps.length][comps.length]; + connections = initConnections(connections); + + for (Entity ent : comps) { + for (String name : ent.getAdjacentEntities()) { + ComponentEntity e2 = findEntity(comps, name); + if (ent != null && e2 != null) { + //System.out.println("^^^^^^^^^ "+e2.getName()); + connections[ent.getId()][e2.getId()] = 1; + } + } + + } + + return connections; + } + + private String[] extractComp(String str) { + + String[] arr = new String[2]; + + if (str.contains("/")) { + arr = str.split("/"); + } else { + arr[0] = str; + arr[1] = null; + } + return arr; + } + + private int[][] initConnections(int[][] connections) { + + for (int i = 0; i < connections.length; i++) { + for (int j = 0; j < connections.length; j++) { + connections[i][j] = 0; + } + } + return connections; + } + + public ComponentEntity[] buildComponentEntities(Element docEle) { + + ComponentEntity[] elts = null; + + // //get the root element + // Element docEle = dom.getDocumentElement(); + // compositeName = docEle.getAttribute("name"); + // System.out.println("compositeName "+compositeName); + + //get a nodelist of elements + NodeList nl = docEle.getElementsByTagName("component"); + if (nl != null && nl.getLength() > 0) { + elts = new ComponentEntity[nl.getLength()]; + + for (int i = 0; i < nl.getLength(); i++) { + elts[i] = new ComponentEntity(); + Element nVal = (Element)nl.item(i); + //System.out.println(nVal.hasAttribute("name")); + elts[i].setId(i); + elts[i].setName(nVal.getAttribute("name")); + + setImplementation(nVal, elts[i]); + setServices(nVal, elts[i]); + setReferences(nVal, elts[i]); + setProperties(nVal, elts[i]); + + elts[i].build(); + } + } + + buildWires(docEle, elts); + // //sec. 5.4 in the spec + // nl = docEle.getElementsByTagName("wire"); + // System.out.println("^^^^^^^^^ "+nl.getLength()); + // if(nl != null && nl.getLength() > 0 ) { + // for(int i = 0 ; i < nl.getLength();i++) { + // Element elt = (Element)nl.item(i); + // String source = elt.getAttribute("source"); + // String target = elt.getAttribute("target"); + // String service, serviceComp, reference, referenceComp; + // + // System.out.println("^^^^^^^^^ "+source+" ::: "+target); + // if(target.contains("/")){ + // String[] arr = target.split("/"); + // serviceComp = arr[0]; + // service = arr[1]; + // } + // else{ + // serviceComp = target; + // service = null; + // } + // + // if(source.contains("/")){ + // String[] arr = source.split("/"); + // referenceComp = arr[0]; + // reference = arr[1]; + // } + // else{ + // referenceComp = source; + // reference = null; + // } + // + // ComponentEntity e = findEntity(referenceComp); + // System.out.println("^^^^^^^^^ "+e.getName()); + // if(e != null){ + // createConnection(e, reference, serviceComp, service); + // } + // } + // } + // + // positionEntities(elts); + // + // calculateProperties(elts); + // print(elts); + + return elts; + + } + + private void buildWires(Element docEle, ComponentEntity[] elts) { + + //sec. 5.4 in the spec + NodeList nl = docEle.getElementsByTagName("wire"); + //System.out.println("^^^^^^^^^ "+nl.getLength()); + if (nl != null && nl.getLength() > 0) { + + for (int i = 0; i < nl.getLength(); i++) { + + Element elt = (Element)nl.item(i); + + String source = elt.getAttribute("source"); + String target = elt.getAttribute("target"); + + String service, serviceComp, reference, referenceComp; + + String[] arr1 = extractComp(target); + serviceComp = arr1[0]; + service = arr1[1]; + + String[] arr2 = extractComp(source); + referenceComp = arr2[0]; + reference = arr2[1]; + + // //System.out.println("^^^^^^^^^ "+source+" ::: "+target); + // if(target.contains("/")){ + // String[] arr = target.split("/"); + // serviceComp = arr[0]; + // service = arr[1]; + // } + // else{ + // serviceComp = target; + // service = null; + // } + // + // if(source.contains("/")){ + // String[] arr = source.split("/"); + // referenceComp = arr[0]; + // reference = arr[1]; + // } + // else{ + // referenceComp = source; + // reference = null; + // } + // + ComponentEntity e1 = findEntity(elts, referenceComp); + //ComponentEntity e2 = findEntity(comps, serviceComp); + + //System.out.println("^^^^^^^^^ "+e1.getName()); + if (e1 != null) { + //System.out.println("^^^^^^^^^ "+e1.getId()); + //connections[e1.getId()][e2.getId()] = 1; + createConnection(e1, reference, serviceComp, service); + } + } + } + + } + + private ComponentEntity findEntity(ComponentEntity[] elts, String componentName) { + + for (ComponentEntity e : elts) { + if (e.getName().equals(componentName)) { + return e; + } + } + return null; + } + + private void setReferences(Element nVal, ComponentEntity ent) { + + NodeList nl = nVal.getElementsByTagName("reference"); + if (nl != null && nl.getLength() > 0) { + for (int i = 0; i < nl.getLength(); i++) { + Element elt = (Element)nl.item(i); + String target = elt.getAttribute("target"); + String ref = elt.getAttribute("name"); + if (target.contains("/")) { + String[] arr = target.split("/"); + createConnection(ent, ref, arr[0], arr[1]); + // ent.addToRefToSerMap(ref, arr[1]); + // ent.addAnAdjacentEntity(arr[0]); + // addToConnectedEntities(ent.getComponentName(), arr[0]); + // addToConnectedEntities(arr[0], ent.getComponentName()); + } else if (!target.equals("")) { + createConnection(ent, ref, target, null); + // ent.addToRefToSerMap(ref, target); + // ent.addAnAdjacentEntity(target); + // addToConnectedEntities(ent.getComponentName(), target); + // addToConnectedEntities(target, ent.getComponentName()); + } + + ent.addAReference(ref); + + } + } + } + + private void createConnection(ComponentEntity ent, String reference, String serviceComp, String service) { + + String referenceComp = ent.getName(); + + if (reference != null && service != null) { + + ent.addToRefToSerMap(reference, serviceComp + "/" + service); + ent.addAnAdjacentEntity(serviceComp); + } else if (reference == null && service != null) { + ent.addToRefToSerMap(referenceComp, serviceComp + "/" + service); + ent.addAnAdjacentEntity(serviceComp); + } else if (reference != null && service == null) { + ent.addToRefToSerMap(reference, serviceComp); + ent.addAnAdjacentEntity(serviceComp); + } else { + ent.addToRefToSerMap(referenceComp, serviceComp); + ent.addAnAdjacentEntity(serviceComp); + } + } + + @SuppressWarnings("unused") + private void print(ComponentEntity[] elts) { + + for (ComponentEntity ent : elts) { + System.out.println(ent.getName() + " : " + + ent.getLevel() + + " : " + + ent.getLane() + + " : " + + ent.getX() + + " : " + + ent.getY()); + } + } + + private void setServices(Element nVal, ComponentEntity ent) { + + NodeList nl = nVal.getElementsByTagName("service"); + if (nl != null && nl.getLength() > 0) { + for (int i = 0; i < nl.getLength(); i++) { + Element elt = (Element)nl.item(i); + ent.addAService(elt.getAttribute("name")); + } + } else { + + NodeList nl1 = nVal.getElementsByTagName("implementation.java"); + if (nl1 != null && nl1.getLength() > 0) { + for (int i = 0; i < nl1.getLength(); i++) { + Element elt = (Element)nl1.item(i); + //System.out.println(elt.getAttribute("class")); + String serName = extractServiceName(elt.getAttribute("class")); + ent.addAService(serName); + } + } + + } + + } + + private void setImplementation(Element nVal, ComponentEntity ent) { + NodeList nodes = nVal.getChildNodes(); + + for (int i = 0; i < nodes.getLength(); i++) { + if (nodes.item(i) instanceof Element) { + Element elt = (Element)nodes.item(i); + String name = elt.getNodeName(); + if (name != null && name.contains(":")) { + name = name.substring(name.indexOf(':') + 1).trim(); + } + if (name != null && name.startsWith("implementation.")) { + String type = name.substring("implementation.".length()); + if ("implementation.java".equals(name)) { + String cls = elt.getAttribute("class"); + ent.setImplementation(type + ":" + extractClassName(cls)); + } else { + ent.setImplementation(type); + } + break; + } + } + } + } + + private String extractClassName(String classAttr) { + if (classAttr == null) { + return ""; + } else { + int index = classAttr.lastIndexOf('.'); + return classAttr.substring(index + 1); + } + } + + /** + * + * This will extract the service name part from the class attribute of + * implementation.java element. + * eg: if class = "NirmalServiceImpl", returning service name would be "NirmalService" + */ + private String extractServiceName(String classAttr) { + if (classAttr != null) { + String[] x = classAttr.split("\\."); + String name = x[x.length - 1]; + if (name.endsWith("Impl")) { + return name.substring(0, name.length() - 4); + } else { + return name; + } + } + return ""; + } + + private void setProperties(Element nVal, ComponentEntity ent) { + + NodeList nl = nVal.getElementsByTagName("property"); + if (nl != null && nl.getLength() > 0) { + for (int i = 0; i < nl.getLength(); i++) { + Element elt = (Element)nl.item(i); + ent.addAProperty(elt.getAttribute("name")); + } + } + } + + // public void setCompositeName(String compositeName) { + // this.compositeName = compositeName; + // } + // + // public String getCompositeName() { + // return compositeName; + // } + + public int getTotalWidth() { + return totalWidth; + } + + public int getTotalHeight() { + return totalHeight; + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/LayoutBuilder.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/LayoutBuilder.java new file mode 100755 index 0000000000..d67dee1629 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/LayoutBuilder.java @@ -0,0 +1,296 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.apache.tuscany.sca.diagram.artifacts.Constant; + +public class LayoutBuilder { + + private Entity[] elts; + private int[][] conns; + private int maxLevels = 8; + + private int totalLevel; + private int totalLane; + + private int totalHeight; + private int totalWidth; + + private int[][] graph; + + /** + * Constructor which takes set of entities and their connection matrix + * + * @param entities + * @param connections + * @param maxLevels + */ + public LayoutBuilder(Entity[] entities, int[][] connections, int maxLevels) { + elts = entities; + graph = connections; // Keep the original connections + + // Clone the connections + int len = connections.length; + conns = new int[len][]; + for (int i = 0; i < len; i++) { + conns[i] = new int[len]; + for (int j = 0; j < len; j++) { + conns[i][j] = connections[i][j]; + } + } + this.maxLevels = maxLevels; + } + + /** + * Layout Building Algorithm + * ~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * Here we position (i.e. assigning a level and a lane) all Entities + * in a unique cell of a grid. + * + * lane0 lane1 lane2 lane3 .... + * _______________________________ + * level0 | | | | | + * |_______|_______|_______|_______| + * level1 | | | | | + * |_______|_______|_______|_______| + * level2 | | | | | + * + * 1) Determining the Entity at level0, lane0 (starting entity) + * -First Entity in the list of Entities which has one or more adjacent Entities + * -If there is only one Entity it will eventually chosen + * + * 2) Get connected Entities of starting Entity. + * * If there are connected entities; + * *For each connected Entity; + * *We assign a corresponding level and a lane + * *Then recurse the procedure for connections of the assigned Entity + * + * + */ + public Entity[] placeEntities() { + + sortEntities(); + + // Build the grid for entities + Entity[][] grid = new Entity[totalLane + 1][totalLevel + 1]; + int[] height = new int[totalLevel + 1]; + int[] width = new int[totalLane + 1]; + + for (Entity e : elts) { + grid[e.getLane()][e.getLevel()] = e; + if (height[e.getLevel()] < e.getHeight() + Constant.COMPONENT_DEFAULT_HEIGHT) { + height[e.getLevel()] = e.getHeight() + Constant.COMPONENT_DEFAULT_HEIGHT; + } + if (width[e.getLane()] < e.getWidth() + Constant.COMPONENT_DEFAULT_WIDTH) { + width[e.getLane()] = e.getWidth() + Constant.COMPONENT_DEFAULT_WIDTH; + } + } + + for (int i = 1; i < totalLane + 1; i++) { + width[i] += width[i - 1]; + } + + for (int j = 1; j < totalLevel + 1; j++) { + height[j] += height[j - 1]; + } + + totalWidth = width[totalLane]; + totalHeight = height[totalLevel]; + + for (int i = 0; i < totalLane + 1; i++) { + for (int j = 0; j < totalLevel + 1; j++) { + Entity ent = grid[i][j]; + if (ent != null) { + int w = ent.getLane() == 0 ? 0 : width[i - 1]; + ent.setX(ent.getParent().getX() + ent.getStartPosition() + w); + int h = ent.getLevel() == 0 ? 0 : height[j - 1]; + ent.setY(ent.getParent().getY() + ent.getStartPosition() / 2 + h); + } + } + } + + return elts; + + } + + private Entity findEntity(int i) { + + for (Entity ent : elts) { + if (ent.getId() == i) { + return ent; + } + } + return null; + } + + private void setPosition(Entity ent, int level, int lane) { + if (totalLane < lane) { + totalLane = lane; + } + if (totalLevel < level) { + totalLevel = level; + } + ent.setLevel(level); + ent.setLane(lane); + ent.setPositionSet(true); + } + + /** + * http://en.wikipedia.org/wiki/Coffman%E2%80%93Graham_algorithm#The_algorithm + * @param sorted + * @param e1 + * @param e2 + * @return + */ + private int compareEntities(List<Integer> sorted, int e1, int e2) { + List<Integer> neighbors1 = findIncomingNeighbors(e1); + List<Integer> neighbors2 = findIncomingNeighbors(e2); + + if (neighbors1.isEmpty() && neighbors2.isEmpty()) { + return 0; + } else if (neighbors1.isEmpty()) { + return -1; + } else if (neighbors2.isEmpty()) { + return 1; + } + + int max = graph.length + 1; + int n1 = max; + int n2 = max; + for (int i = sorted.size() - 1; i >= 0; i--) { + if (neighbors1.contains(sorted.get(i))) { + n1 = i; + } + if (neighbors2.contains(sorted.get(i))) { + n2 = i; + } + if (n1 == n2) { + // Need to try the 2nd most recently added incoming neighbor + // Reset the indexes and continue + n1 = max; + n2 = max; + continue; + } + } + return n1 - n2; + } + + private List<Integer> findIncomingNeighbors(int e1) { + // Get all the inbound connections for a given entity + List<Integer> ins = new ArrayList<Integer>(); + for (int i = 0; i < graph.length; i++) { + if (graph[i][e1] == 1) { + ins.add(i); + } + } + return ins; + } + + /** + * Perform a topological sort on the graph so that we can place the entities into level/lane grids + * http://en.wikipedia.org/wiki/Coffman%E2%80%93Graham_algorithm#The_algorithm + */ + List<Integer> sortEntities() { + int lane = 0; + final List<Integer> sorted = new ArrayList<Integer>(); + while (true) { + List<Integer> ids = new ArrayList<Integer>(); + for (int i = 0; i < conns.length; i++) { + Entity ent = findEntity(i); + if (ent.isPositionSet()) { + continue; + } + boolean beingConnected = false; + for (int j = 0; j < conns.length; j++) { + if (conns[j][i] == 1) { + beingConnected = true; + break; + } + } + if (!beingConnected) { + ids.add(i); + } + } + + if (ids.isEmpty()) { + boolean end = true; + // There might be circular dependencies + for (Entity e : elts) { + if (!e.isPositionSet()) { + // Pick the first one + ids.add(e.getId()); + end = false; + break; + } + } + if (end) { + return sorted; + } + } + int level = 0; + Collections.sort(ids, new Comparator<Integer>() { + + @Override + public int compare(Integer e1, Integer e2) { + return compareEntities(sorted, e1, e2); + } + }); + for (int i : ids) { + sorted.add(i); + + if (maxLevels > 0 && level > 0 && (level % maxLevels == 0)) { + // Overflow to the next lane + level = 0; + lane++; + } + + setPosition(findEntity(i), level++, lane); + for (int j = 0; j < conns.length; j++) { + // Remove the connections from i + conns[i][j] = 0; + } + } + lane++; + } + } + + public int getTotalLevel() { + return totalLevel; + } + + public int getTotalLane() { + return totalLane; + } + + public int getTotalHeight() { + return totalHeight; + } + + public int getTotalWidth() { + return totalWidth; + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/TuscanyCompositeEntityBuilder.java b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/TuscanyCompositeEntityBuilder.java new file mode 100755 index 0000000000..ef8dd3b27e --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/composite-diagram/src/main/java/org/apache/tuscany/sca/diagram/layout/TuscanyCompositeEntityBuilder.java @@ -0,0 +1,378 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.diagram.layout; + +import java.util.List; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.Component; +import org.apache.tuscany.sca.assembly.ComponentProperty; +import org.apache.tuscany.sca.assembly.ComponentReference; +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Composite; +import org.apache.tuscany.sca.assembly.CompositeReference; +import org.apache.tuscany.sca.assembly.CompositeService; +import org.apache.tuscany.sca.assembly.Endpoint; +import org.apache.tuscany.sca.assembly.EndpointReference; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.Property; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.Wire; +import org.apache.tuscany.sca.diagram.artifacts.Artifact; +import org.apache.tuscany.sca.diagram.artifacts.Constant; +import org.apache.tuscany.sca.implementation.java.JavaImplementation; + +public class TuscanyCompositeEntityBuilder { + + private Composite tuscanyComp; + + private int totalWidth = 0; + private int totalHeight = 0; + + CompositeEntity composite = null; + + /** + * Constructor which initiates the DOM document + * @param aDom DOM document + */ + public TuscanyCompositeEntityBuilder(Composite comp) { + tuscanyComp = comp; + } + + public CompositeEntity buildCompositeEntity() { + + String compositeName = tuscanyComp.getName().getLocalPart(); + // System.out.println("compositeName " + compositeName); + + ComponentEntity[] comps = buildComponentEntities(); + + buildTargets(comps); + buildWires(tuscanyComp.getWires(), comps); + + composite = new CompositeEntity(compositeName); + + setParent(comps); + + // System.out.println("ComponentEntity " + comps[0].getId()); + int[][] conns = buildConnectionMatrix(comps); + // System.out.println("ComponentEntity " + conns[0][0]); + + composite.setComponentList(comps); + composite.setConnections(conns); + + LayoutBuilder buildLayout = new LayoutBuilder(comps, conns, Constant.MAX_LEVELS); + buildLayout.placeEntities(); + composite.setHeight(buildLayout.getTotalHeight()); + composite.setWidth(buildLayout.getTotalWidth()); + composite.setMaxInternalLane(buildLayout.getTotalLane()); + composite.setMaxInternalLevel(buildLayout.getTotalLevel()); + + // System.out.println("conns " + conns[0][0]); + + buildCompositeService(); + buildCompositeReference(); + buildCompositeProperty(); + + addInclusions(); + + composite.build(); + + return composite; + } + + private void setParent(ComponentEntity[] comps) { + + for (ComponentEntity comp : comps) { + comp.setParent(composite); + } + } + + private void buildCompositeService() { + + List<Service> sers = tuscanyComp.getServices(); + + for (int i = 0; i < sers.size(); i++) { + Service compositeSer = sers.get(i); + composite.addAService(compositeSer.getName()); + String service = ((CompositeService)compositeSer).getPromotedService().getName(); + + composite.addToPromoteAService(compositeSer.getName(), service); + } + + } + + private void buildCompositeReference() { + + List<Reference> refs = tuscanyComp.getReferences(); + + for (int i = 0; i < refs.size(); i++) { + Reference compositeRef = refs.get(i); + composite.addAReference(compositeRef.getName()); + + List<ComponentReference> promotedRefs = ((CompositeReference)compositeRef).getPromotedReferences(); + + for (ComponentReference ref : promotedRefs) { + String reference = ref.getName(); + + composite.addToPromoteAReference(compositeRef.getName(), reference); + } + + } + + } + + private void buildCompositeProperty() { + + List<Property> props = tuscanyComp.getProperties(); + + for (int i = 0; i < props.size(); i++) { + Property compositeProp = props.get(i); + composite.addAProperty(compositeProp.getName()); + } + + } + + private void addInclusions() { + + List<Composite> includes = tuscanyComp.getIncludes(); + + for (int i = 0; i < includes.size(); i++) { + Composite anInclude = includes.get(i); + composite.addToIncludedComposites(anInclude.getName().getLocalPart()); + } + + } + + private int[][] buildConnectionMatrix(ComponentEntity[] comps) { + + int[][] connections = new int[comps.length][comps.length]; + connections = initConnections(connections); + + for (Entity ent : comps) { + for (String name : ent.getAdjacentEntities()) { + ComponentEntity e2 = findEntity(comps, name); + if (ent != null && e2 != null) { + //System.out.println("^^^^^^^^^ "+e2.getName()); + connections[ent.getId()][e2.getId()] = 1; + } + } + + } + + return connections; + } + + private String extractComp(ComponentEntity[] elts, String str, boolean isReference) { + String[] names = Artifact.parseNames(str); + if (isReference) { + for (ComponentEntity elt : elts) { + if (elt.getName().equals(names[0])) { + for (String ref : elt.getReferences()) { + if (ref.equals(names[1])) { + return elt.getName(); + } + } + } + } + } else { + for (ComponentEntity elt : elts) { + if (elt.getName().equals(names[0])) { + for (String ser : elt.getServices()) { + if (ser.equals(names[1])) { + return elt.getName(); + } + } + } + } + } + return ""; + + } + + private int[][] initConnections(int[][] connections) { + + for (int i = 0; i < connections.length; i++) { + for (int j = 0; j < connections.length; j++) { + connections[i][j] = 0; + } + } + return connections; + } + + public ComponentEntity[] buildComponentEntities() { + + ComponentEntity[] elts = null; + + List<Component> components = tuscanyComp.getComponents(); + + elts = new ComponentEntity[components.size()]; + + for (int i = 0; i < components.size(); i++) { + Component aComp = components.get(i); + + elts[i] = new ComponentEntity(); + elts[i].setId(i); + elts[i].setName(aComp.getName()); + + Implementation implementation = aComp.getImplementation(); + if (implementation != null) { + String impl = ""; + QName type = implementation.getType(); + if (JavaImplementation.TYPE.equals(type)) { + impl = "java:" + ((JavaImplementation)implementation).getJavaClass().getSimpleName(); + } else if (implementation instanceof Composite) { + impl = "composite:" + ((Composite)implementation).getName().getLocalPart(); + } else { + impl = type.getLocalPart(); + } + elts[i].setImplementation(impl); + } + + setServices(aComp.getServices(), elts[i]); + setReferences(aComp.getReferences(), elts[i]); + setProperties(aComp.getProperties(), elts[i]); + + elts[i].build(); + } + + return elts; + + } + + private void buildTargets(ComponentEntity[] components) { + + for (Component c : tuscanyComp.getComponents()) { + ComponentEntity sourceComponent = findEntity(components, c.getName()); + for (ComponentReference ref : c.getReferences()) { + for (EndpointReference epr : ref.getEndpointReferences()) { + Endpoint ep = epr.getTargetEndpoint(); + if (ep != null && ep.getComponent() != null && ep.getService() != null) { + createConnection(sourceComponent, ref.getName(), ep.getComponent().getName(), ep.getService() + .getName()); + } + } + } + } + } + + private void buildWires(List<Wire> wires, ComponentEntity[] elts) { + + for (int i = 0; i < wires.size(); i++) { + String service, serviceComp, reference, referenceComp; + Wire aWire = wires.get(i); + + reference = aWire.getSource().getName(); + service = aWire.getTarget().getName(); + + referenceComp = extractComp(elts, reference, true); + serviceComp = extractComp(elts, service, false); + + ComponentEntity e1 = findEntity(elts, referenceComp); + + //System.out.println("^^^^^^^^^ "+e1.getName()); + if (e1 != null) { + //System.out.println("^^^^^^^^^ "+e1.getId()); + //connections[e1.getId()][e2.getId()] = 1; + createConnection(e1, reference, serviceComp, service); + } + } + + } + + private ComponentEntity findEntity(ComponentEntity[] elts, String componentName) { + + for (ComponentEntity e : elts) { + if (e.getName().equals(componentName)) { + return e; + } + } + return null; + } + + private void setReferences(List<ComponentReference> refs, ComponentEntity ent) { + + for (int i = 0; i < refs.size(); i++) { + ent.addAReference(refs.get(i).getName()); + } + + } + + private void createConnection(ComponentEntity ent, String reference, String serviceComp, String service) { + + String referenceComp = ent.getName(); + + if (reference != null && service != null) { + + ent.addToRefToSerMap(reference, serviceComp + "/" + service); + ent.addAnAdjacentEntity(serviceComp); + } else if (reference == null && service != null) { + ent.addToRefToSerMap(referenceComp, serviceComp + "/" + service); + ent.addAnAdjacentEntity(serviceComp); + } else if (reference != null && service == null) { + ent.addToRefToSerMap(reference, serviceComp); + ent.addAnAdjacentEntity(serviceComp); + } else { + ent.addToRefToSerMap(referenceComp, serviceComp); + ent.addAnAdjacentEntity(serviceComp); + } + } + + @SuppressWarnings("unused") + private void print(ComponentEntity[] elts) { + + for (ComponentEntity ent : elts) { + System.out.println(ent.getName() + " : " + + ent.getLevel() + + " : " + + ent.getLane() + + " : " + + ent.getX() + + " : " + + ent.getY()); + } + } + + private void setServices(List<ComponentService> sers, ComponentEntity ent) { + + for (int i = 0; i < sers.size(); i++) { + ent.addAService(sers.get(i).getName()); + } + + } + + private void setProperties(List<ComponentProperty> props, ComponentEntity ent) { + + for (int i = 0; i < props.size(); i++) { + ent.addAProperty(props.get(i).getName()); + } + + } + + public int getTotalWidth() { + return totalWidth; + } + + public int getTotalHeight() { + return totalHeight; + } + +} |