import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
@Override
public Graph<String, String> createGraph() {
	Tree<String, String> graph = new DelegateTree<String, String>();
	if (clusterModel.getRootNode() == null) {
		return graph;
	}

	HierarchicalClusterNode root = clusterModel.getRootNode();
	graph.addVertex("Root");
	vertexMap.put("Root", root);

	for (HierarchicalClusterNode subNode : clusterModel.getRootNode().getSubNodes()) {
		createGraph(graph, "Root", subNode);
	}
	return graph;
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
private Forest generateGraph()
    {
        /*position vertices in graph*/
//        DirectedSparseGraph<Node, HyperEdge> graph  =
//                new DirectedSparseGraph<Node, HyperEdge>();
        DelegateTree graph  =
                new DelegateTree<HyperEdge, Node>();
        EventsNode ev0 = new EventsNode(0, 5);
//        TrackNode tr1 = new TrackNode(0, 1, 0, 0, true, true);
        TrackNode tr1 = new TrackNode(0, 1, 0, 0);
        EventsNode ev1 = new EventsNode(1, 0);
        graph.addVertex(ev0);
        graph.addChild(new HyperEdge(1.0), ev0, ev1);
        graph.addChild(new HyperEdge(1.0), ev0, tr1);
        
//        graph.addEdge(ev0, Arrays.asList(ev1, tr1));
//        graph.addEdge(new HyperEdge(1.0), ev0, tr1);

        return graph;
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
@Override
    public void afterPropertiesSet() {

        // for each tenant
        //build tree from itemassoc
        List<TenantVO> tenants = tenantService.getAllTenants();
        for (TenantVO tenantVO : tenants) {
//            logger.info("building Cluster tree for tenant " + tenantVO.getId());
            initTenantForClusters(tenantVO);

            DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tenantClusters =
                    clusters.get(tenantVO.getId());
            buildTree(tenantClusters, tenantClusters.getRoot());
            //clusters.put(tenantVO.getId(), tenantClusters);
        }
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
private void buildTree(
        DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree,
        ClusterVO vertex) {
    Integer assocTypeCluster =
            assocTypeDAO.getIdOfType(vertex.getItem().getTenant(), ClusterService.ASSOCTYPE_CLUSTER);

    List<ItemAssocVO<Integer,Integer>> edges = itemAssocService
            .getItemAssocs(vertex.getItem(), assocTypeCluster, null,
                    new IAConstraintVO<Integer, Integer>(null, vertex.getItem().getTenant()));

    for (ItemAssocVO<Integer,Integer> edge : edges) {
        ItemVO<Integer, Integer> child = edge.getItemTo();
        ClusterVO childVertex = loadCluster(child.getTenant(), child.getItem(), child.getType());
        if (childVertex != null) {
            tree.addChild(edge, vertex, childVertex);
            buildTree(tree, childVertex);
        }
    }
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
private void removeClustersFromDB(
        DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree,
        ClusterVO vertex) {
    List<ItemAssocVO<Integer,Integer>> edges =
            itemAssocService.getItemAssocsForItem(vertex.getItem().getTenant(), vertex.getItem(), null);
    //remove all edges in db
    for (ItemAssocVO<Integer,Integer> edge : edges) {
        itemAssocService.removeItemAssoc(edge.getId());
    }
    profileDAO.deactivateProfile(vertex.getItem().getTenant(), vertex.getItem().getItem(),
            vertex.getItem().getType());
    // remove all items from cluster
    for (ItemVO<Integer, Integer> item : getItemsOfCluster(vertex)) {
        try {
            removeItemFromCluster(vertex, item);
        } catch (ClusterException ce) {
            logger.error(ce.getMessage());
        }
    }
    for (ClusterVO child : tree.getChildren(vertex)) {
        removeClustersFromDB(tree, child);
    }
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
/**
     * Class constructor 
     * 
     * @param phylogeny describes the tree, which will be created. 
     */
    public CreatePhyloTreeGraph(Phylogeny phylogeny) {
        g3 = new DelegateTree<Cell, Clade>();
        
        List<Clade> cladeList = phylogeny.getAllCladeInPhylogeny();
        List<Cell> cellsList = new ArrayList<Cell>();//phylogeny.getForest().getCellsListFromCladesList(cladeList);
        Clade rootClade = phylogeny.getRootClade();
        g3.setRoot(rootClade.getCellObject());
        int leng = cladeList.size();
        for(int i=1; i < leng ; i++) {
            Clade cld = cladeList.get(i);
            Cell cell = cld.getCellObject();
            cell.setPhyloTreeGraph(g3);
            cellsList.add(cell);
            Cell parentCell = cell.getParentCell();
            g3.addChild(cld, parentCell, cell);
        }
//        for(int i=1; i < cellsList.size() ; i++) {
//            cellsList.get(i).setPhyloTreeGraph(g3);
//        }
//        System.out.println("g3-Height: " + g3.getHeight());
//        g2.addTree(g3);
        
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
/**
 * Get the hierarchy of {@link ConstraintSolver}s rooted in this {@link MultiConstraintSolver}.
 * @return The hierarchy of {@link ConstraintSolver}s rooted in this {@link MultiConstraintSolver}.
 */
public DelegateTree<ConstraintSolver,String> getConstraintSolverHierarchy() {
	DelegateTree<ConstraintSolver,String> ret = new DelegateTree<ConstraintSolver, String>();
	ret.setRoot(this);
	ConstraintSolver[] myConstraintSolvers = this.getConstraintSolvers();
	for (int i = 0; i < myConstraintSolvers.length; i++) {
		String edgeLabel = i + " (" + this.hashCode() + ")";
		if (myConstraintSolvers[i] instanceof MultiConstraintSolver) {
			DelegateTree<ConstraintSolver,String> subtree = ((MultiConstraintSolver)myConstraintSolvers[i]).getConstraintSolverHierarchy();
			TreeUtils.addSubTree(ret, subtree, this, edgeLabel);
		}
		else {
			ret.addChild(edgeLabel, this, myConstraintSolvers[i]);
		}
	}
	return ret;
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
/**
 * Get a tree whose nodes are the constraint networks managed by the hierarchy of
 * {@link ConstraintSolver}s underlying this {@link MultiConstraintSolver}.
 * @return A tree whose nodes are the constraint networks managed by the hierarchy of
 * {@link ConstraintSolver}s underlying this {@link MultiConstraintSolver}.
 */
public DelegateTree<ConstraintNetwork,String> getConstraintNetworkHierarchy() {
	DelegateTree<ConstraintNetwork,String> ret = new DelegateTree<ConstraintNetwork, String>();
	ConstraintNetwork myCN = this.getConstraintNetwork();
	ret.setRoot(myCN);
	ConstraintSolver[] myConstraintSolvers = this.getConstraintSolvers();
	for (int i = 0; i < myConstraintSolvers.length; i++) {
		String edgeLabel = i + " (" + this.hashCode() + ")";
		if (myConstraintSolvers[i] instanceof MultiConstraintSolver) {
			DelegateTree<ConstraintNetwork,String> subtree = ((MultiConstraintSolver)myConstraintSolvers[i]).getConstraintNetworkHierarchy();
			TreeUtils.addSubTree(ret, subtree, myCN, edgeLabel);
		}
		else {
			ret.addChild(edgeLabel, myCN, myConstraintSolvers[i].getConstraintNetwork());
		}
	}
	return ret;
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public ClusterServiceImpl(ProfileDAO profileDAO,
                          ItemAssocService itemAssocService,
                          IDMappingDAO idMappingDAO,
                          TenantService tenantService,
                          ItemTypeDAO itemTypeDAO,
                          AssocTypeDAO assocTypeDAO,
                          SourceTypeDAO sourceTypeDAO,
                          ViewTypeDAO viewTypeDAO) {
    this.profileDAO = profileDAO;
    this.itemAssocService = itemAssocService;
    this.tenantService = tenantService;
    this.idMappingDAO = idMappingDAO;
    this.itemTypeDAO = itemTypeDAO;
    this.assocTypeDAO = assocTypeDAO;
    this.sourceTypeDAO = sourceTypeDAO;
    this.viewTypeDAO = viewTypeDAO;
    this.clusters =
            new HashMap<Integer, DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>>>();
    try {
        context = JAXBContext.newInstance(org.easyrec.model.core.ClusterVO.class);
    } catch (Exception e) {
        logger.error("Could not instantiate JAXB Context for ClusterService!", e);
    }
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public Collection<Tree<V, E>> getTrees() {
	Collection<Tree<V,E>> trees = new HashSet<Tree<V,E>>();
	for(V v : getRoots()) {
		Tree<V,E> tree = new DelegateTree<V,E>();
		tree.addVertex(v);
		TreeUtils.growSubTree(this, tree, v);
		trees.add(tree);
	}
	return trees;
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public void addCluster(ClusterVO cluster, ClusterVO parent) throws ClusterException {

        DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
                clusters.get(parent.getItem().getTenant());
        if (tree.containsVertex(cluster)) throw new ClusterException("Cannot add cluster! Cluster already exists!");
        if (tree.containsVertex(parent)) {
            storeCluster(cluster);
            ItemAssocVO<Integer,Integer> edge =
                    new ItemAssocVO<Integer,Integer>(
                            parent.getItem().getTenant(), // tenantId
                            parent.getItem(), //itemFrom
                            assocTypeDAO.getIdOfType(parent.getItem().getTenant(), ClusterService.ASSOCTYPE_CLUSTER),
                            //assocType
                            1.0, //assocValue
                            cluster.getItem(), //itemTo
                            sourceTypeDAO.getIdOfType(parent.getItem().getTenant(),
                                    SourceTypeDAO.SOURCETYPE_MANUALLY_CREATED), //sourceType
                            "", //comment
                            viewTypeDAO.getIdOfType(parent.getItem().getTenant(), ViewTypeDAO.VIEWTYPE_ADMIN),
                            true); //timeStamp
            itemAssocService.insertOrUpdateItemAssoc(edge);
            tree.addChild(edge, parent, cluster);
        } else {
            throw new ClusterException("Parent cluster could not be found!");
        }

        //check if profile with name already exists
        // if yes reject : cluster already exists
        // else check if parent exists, if not reject.
        // find parent;
        // insert child;
        // store itemassoc
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public void removeCluster(Integer tenantId, String name) {

        //remove itemassoc (tree); if not leaf, remove whole subtree
        DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
                clusters.get(tenantId);
        ClusterVO cluster = loadCluster(tenantId, idMappingDAO.lookup(name),
                itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER));
        // disconnect subtree
        ItemAssocVO<Integer,Integer> parentEdge = tree.getParentEdge(cluster);
        itemAssocService.removeItemAssoc(parentEdge.getId());
        //now remove rest of subtree including all itemassocs (item->cluster)
        removeClustersFromDB(tree, cluster);
        tree.removeChild(cluster);
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public void moveCluster(Integer tenantId, String clusterName, String newParent) {

        DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
                clusters.get(tenantId);
        ClusterVO cluster = loadCluster(tenantId, idMappingDAO.lookup(clusterName),
                itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER));
        // disconnect subtree
        ItemAssocVO<Integer,Integer> parentEdge = tree.getParentEdge(cluster);
        itemAssocService.removeItemAssoc(parentEdge.getId());
        tree.removeChild(cluster);

        // add cluster as child to new parent
        ClusterVO parent = loadCluster(tenantId, idMappingDAO.lookup(newParent),
                itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER));

        ItemAssocVO<Integer,Integer> edge =
                new ItemAssocVO<Integer,Integer>(
                        parent.getItem().getTenant(), // tenantId
                        parent.getItem(), //itemFrom
                        assocTypeDAO.getIdOfType(parent.getItem().getTenant(), ClusterService.ASSOCTYPE_CLUSTER),
                        //assocType
                        1.0, //assocValue
                        cluster.getItem(), //itemTo
                        sourceTypeDAO.getIdOfType(parent.getItem().getTenant(),
                                SourceTypeDAO.SOURCETYPE_MANUALLY_CREATED), //sourceType
                        "", //comment
                        viewTypeDAO.getIdOfType(parent.getItem().getTenant(), ViewTypeDAO.VIEWTYPE_ADMIN),
                        true); //timeStamp
        itemAssocService.insertOrUpdateItemAssoc(edge);
        tree.addChild(edge, parent, cluster);
        buildTree(tree, cluster);
    }
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public void renameCluster(Integer tenantId, String clusterName, String newName) throws ClusterException {
    ClusterVO cluster = loadCluster(tenantId, idMappingDAO.lookup(clusterName),
            itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER));
    DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
            clusters.get(tenantId);
    if (tree.isRoot(cluster)) throw new ClusterException("ROOT cluster cannot be renamed!");
    ClusterVO parent = tree.getParent(cluster);
    ClusterVO newCluster = new ClusterVO(tenantId, idMappingDAO.lookup(newName),
            itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER), newName, cluster.getDescription());
    // add the new cluster
    addCluster(newCluster, parent);
    // move all children to the new cluster
    for (ClusterVO child : tree.getChildren(cluster)) {
        moveCluster(tenantId, child.getName(), newName);
    }
    if (logger.isDebugEnabled()) {
        logger.debug("removed all children: " + tree.isLeaf(cluster));
    }

    // move all items to the new cluster
    for (ItemVO<Integer, Integer> item : getItemsOfCluster(cluster)) {
        addItemToCluster(newCluster, item);
    }

    // delete the old cluster
    removeCluster(tenantId, clusterName);

}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public void updateClusterDescription(Integer tenantId, String clusterName, String newDescription)
        throws ClusterException {

    ClusterVO cluster = loadCluster(tenantId, idMappingDAO.lookup(clusterName),
            itemTypeDAO.getIdOfType(tenantId, ClusterService.ITEMTYPE_CLUSTER));
    DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
            clusters.get(tenantId);
    if (tree.isRoot(cluster)) throw new ClusterException("ROOT cluster description cannot be changed!");

    cluster.setDescription(newDescription);
    storeCluster(cluster);

}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public ClusterVO getParent(Integer tenantId, ClusterVO cluster) {
    DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
            clusters.get(tenantId);
    // root has no parent
    if (tree.isRoot(cluster)) return null;
    return tree.getParent(cluster);
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public List<ClusterVO> getSiblings(Integer tenantId, ClusterVO cluster) {
    DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> tree =
            clusters.get(tenantId);
    if (tree.isRoot(cluster)) return null; //root has no siblings
    ClusterVO parent = tree.getParent(cluster);
    Collection<ClusterVO> sibl = tree.getChildren(parent);
    List<ClusterVO> siblings = new ArrayList<ClusterVO>();
    for (ClusterVO clusterVO : sibl) {
        if (!clusterVO.equals(cluster)) siblings.add(clusterVO);
    }
    return siblings;
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
@Test
public void testLoadClusters() {
     DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> clusters = clusterService.getClustersForTenant(1);
     ClusterVO root = clusters.getRoot();
     printCluster(clusters, root);
     assertThat(clusters.getHeight(), is(2));
     assertThat(clusters.getChildCount(root), is(2));
     assertThat(clusters.getVertexCount(), is(5));

}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
@Test
public void testGetSiblings() {
     DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>> clusters = clusterService.getClustersForTenant(1);
     List<ClusterVO> siblings = clusterService.getSiblings(1, "CLUSTER1");
     for (ClusterVO clusterVO : siblings) {
        logger.info("Sibling of CLUSTER1: " + clusterVO.getName());
     }
     printCluster(clusters,clusters.getRoot());
     assertThat(siblings.size(), is(1));
     assertThat(siblings.get(0).getName(), is("CLUSTER2"));
}
 

import edu.uci.ics.jung.graph.DelegateTree; //导入依赖的package包/类
public ModelAndView loadtreedata(HttpServletRequest request, HttpServletResponse httpServletResponse) {
    ModelAndView mav = new ModelAndView("clustermanager/ajax/loadtreedata");

    RemoteTenant remoteTenant = viewInitializationService.initializeView(request, mav);

    if (remoteTenant == null) {
        logger.warn("no tenantId supplied");
        return mav;
    }

    DelegateTree<ClusterVO, ItemAssocVO<Integer,Integer>>
            clusterTree = clusterService.getClustersForTenant(remoteTenant.getId());

    ObjectMapper om = new ObjectMapper();
    StringWriter sw = new StringWriter();
    JsonTreeGraphWriterJackson converter = new JsonTreeGraphWriterJackson();
    ClusterNode n = converter.convert(clusterTree);
    try {
        om.writeValue(sw, n);
    } catch (IOException ex) {
       logger.warn("failed to serialize cluster tree to JSON", ex);
    }
    String tree = sw.toString();

    mav.addObject("treeJsonData", tree);

    return mav;
}