How to use

Digraph

in

org.objectstyle.ashwood.graph

public static Digraph randomize(Digraph digraph, int order, int size, Random randomizer) {
 for (int i = 1; i <= order; i++) digraph.addVertex(new Integer(i));
 Random random = randomizer;
 int n_2 = order*order;
 size = Math.min(size, n_2);
 for (int arc = 1; arc <= size; arc++) {
  int arcCode = random.nextInt(n_2);
  int origin = arcCode / order + 1;
  int dst = arcCode % order + 1;
  digraph.putArc(new Integer(origin), new Integer(dst), new Integer(arc));
 }
 return digraph;
}

 public boolean evaluate(Object parameter) {
  return graph.containsVertex(parameter);
 }
}

public static Map computeLevels(Map vertexLevelMap,
                Digraph digraph,
                boolean longest) {
 if (vertexLevelMap == null)
  vertexLevelMap = new HashMap(digraph.order());
 for (Iterator i = digraph.vertexIterator(); i.hasNext(); ) {
  Object rootCandidate = i.next();
  if (digraph.incomingSize(rootCandidate) == 0)
   computeLevels(vertexLevelMap,
          digraph,
          rootCandidate,
          longest);
 }
 return vertexLevelMap;
}

private static Digraph createDigraph2() {
  Digraph digraph = new MapDigraph(MapDigraph.HASHMAP_FACTORY);
  String[] vertices = new String[] { "A", "B", "C", "D", "E", "F" };
  digraph.addAllVertices(Arrays.asList(vertices));
  digraph.putArc("A", "B", Boolean.TRUE);
  digraph.putArc("A", "F", Boolean.TRUE);
  digraph.putArc("B", "C", Boolean.TRUE);
  digraph.putArc("F", "D", Boolean.TRUE);
  digraph.putArc("C", "D", Boolean.TRUE);
  digraph.putArc("E", "D", Boolean.TRUE);
  return digraph;
}

public static Digraph randomizeAcyclic(Digraph digraph, int order, int incomingSize, int outgoingSize, Random randomizer) {
 Random random = randomizer;
 int arc = 1;
 for (int i = 1; i <= order; i++) {
  Integer destination = new Integer(i);
  digraph.addVertex(destination);
  for (int j = 0; j < incomingSize; j++) {
   int org = random.nextInt(i);
   if (org == 0) continue;
   Integer origin = new Integer(org);
   if (digraph.outgoingSize(origin) >= outgoingSize) continue;
   digraph.putArc(origin, destination, new Integer(arc++));
  }
 }
 return digraph;
}

private void createWrapperDigraph() {
  wrapperDigraph = new MapDigraph(MapDigraph.HASHMAP_FACTORY);
  vertexWrapperMap = new HashMap(digraph.order());
  for (Iterator i = digraph.vertexIterator(); i.hasNext();) {
    Object vertex = i.next();
    VertexWrapper wrapper = new VertexWrapper(vertex);
    vertexWrapperMap.put(vertex, wrapper);
    wrapperDigraph.addVertex(wrapper);
  }
  for (ArcIterator i = digraph.arcIterator(); i.hasNext();) {
    i.next();
    Object wrapper1 = vertexWrapperMap.get(i.getOrigin());
    Object wrapper2 = vertexWrapperMap.get(i.getDestination());
    if (rootsUpwards)
      wrapperDigraph.putArc(wrapper1, wrapper2, Boolean.TRUE);
    else
      wrapperDigraph.putArc(wrapper2, wrapper1, Boolean.TRUE);
  }
}

Map vertexMap = new HashMap(digraph.order());
longArcDigraph = new MapDigraph();
for (Iterator i = digraph.vertexIterator(); i.hasNext(); ) {
 Object vertex = i.next();
 int rank = rankFunction.intValue(vertex);
 if (wrapper == null) {
  wrapper = new LayerVertex(
    vertex, digraph.incomingSize(vertex), digraph.outgoingSize(vertex));
  if (vertexShape != null)
   wrapper.setGeometry(vertexShape);
 for (ArcIterator j = digraph.outgoingIterator(vertex); j.hasNext(); ) {
  j.next();
  Object dst = j.getDestination();
  if (dstWrapper == null) {
   dstWrapper = new LayerVertex(
     dst, digraph.incomingSize(dst), digraph.outgoingSize(dst));
   if (vertexShape != null)
    dstWrapper.setGeometry(vertexShape);
   LayerVertex dummy = new LayerVertex(null, 1, 1);
   if (k == 1)
    longArcDigraph.putArc(wrapper, dstWrapper, dummy);
   origin.getSuccessors().add(dummy);
   dummy.getPredecessors().add(origin);
 for (ArcIterator i = longArcDigraph.arcIterator(); i.hasNext(); ) {

  public static Digraph buildReferentialDigraph(Digraph digraph,
      Collection tables) {
    HashMap tableMap = new HashMap();
    for (Iterator i = tables.iterator(); i.hasNext();) {
      Table table = (Table) i.next();
      tableMap.put(table.getFullName(), table);
      digraph.addVertex(table);
    }
    for (Iterator i = tables.iterator(); i.hasNext();) {
      Table dst = (Table) i.next();
      for (Iterator j = dst.getForeignKeys().iterator(); j.hasNext();) {
        ForeignKey fk = (ForeignKey) j.next();
        String pkTableFullName = Table.composeFullName(fk
            .getPkTableCatalog(), fk.getPkTableSchema(), fk
            .getPkTableName());
        Table origin = (Table) tableMap.get(pkTableFullName);
        if (origin != null) {
          ArrayList fks = (ArrayList) digraph.getArc(origin, dst);
          if (fks == null) {
            fks = new ArrayList();
            digraph.putArc(origin, dst, fks);
          }
          fks.add(fk);
        }
      }
    }
    return digraph;
  }
}

        continue;
      pkDependencyGraph.putArc(origin, dst, Boolean.TRUE);
for (Iterator i = dbEntitiesToResolve.iterator(); i.hasNext();) {
  DbEntity entity = (DbEntity) i.next();
  if (!pkDependencyGraph.containsVertex(entity)) {
    indexedDbEntities.put(entity, new Integer(index++));

 LayerVertex v1 = layers[i].getVertex(j);
 LayerVertex v2 = layers[i].getVertex(j + 1);
 subgraphOrderingGraph.putArc(v1, v2, Boolean.TRUE);
 NestingTreeNode origin = v1.getParentSubgraph();
 NestingTreeNode dst = v2.getParentSubgraph();
 subgraphOrderingGraph.addVertex(origin);
 subgraphOrderingGraph.addVertex(dst);
 if (origin == dst) continue;
 if (origin == root) origin = v1;
 if (dst == root) dst = v2;
 subgraphOrderingGraph.putArc(origin, dst, Boolean.TRUE);
 subgraphOrderingGraph.removeArc(
   cycle.get(minWeightIndex - 1), cycle.get(minWeightIndex));
} else {
 subgraphOrderingGraph.removeArc(
   cycle.get(cycle.size() - 1), cycle.get(0));

public int order() {
 return digraph.order();
}

public static boolean isAcyclic(Digraph digraph) {
 int order = digraph.order();
 if (order == 0) return true;
 Set spanned = new HashSet(order);
 DepthFirstStampSearch dfs = new DepthFirstStampSearch(digraph, digraph.vertexIterator().next());
 for (Iterator i = digraph.vertexIterator(); i.hasNext();) {
  Object dfsRoot = i.next();
  if (spanned.contains(dfsRoot)) continue;
  dfs.reset(dfsRoot);
  Map dfsOrders = dfs.traverse(new HashMap(digraph.order()));
  for (Iterator j = dfsOrders.entrySet().iterator(); j.hasNext();) {
   Map.Entry entry = (Map.Entry)j.next();
   Object origin = entry.getKey();
   DepthFirstStampSearch.OrderPair orgOrders = (DepthFirstStampSearch.OrderPair)entry.getValue();
   spanned.add(origin);
   for (ArcIterator k = digraph.outgoingIterator(origin); k.hasNext();) {
    k.next();
    Object dst = k.getDestination();
    DepthFirstStampSearch.OrderPair dstOrders = (DepthFirstStampSearch.OrderPair)dfsOrders.get(dst);
    if (dstOrders.getPostOrder() > orgOrders.getPostOrder()) return false;
   }
  }
  if (dfsOrders.size() == order) break;
 }
 return true;
}

private void splitLongArcs() {
  for (ArcIterator i = wrapperDigraph.arcIterator(); i.hasNext();) {
    i.next();
    Object origin = i.getOrigin();
    Pair splitArc = (Pair) entry.getKey();
    List dummyWrappers = (List) entry.getValue();
    wrapperDigraph.removeArc(splitArc.first, splitArc.second);
    Object origin = splitArc.first;
    for (Iterator j = dummyWrappers.iterator(); j.hasNext();) {
      Object dummyVertex = j.next();
      wrapperDigraph.putArc(origin, dummyVertex, Boolean.TRUE);
      origin = dummyVertex;
    wrapperDigraph.putArc(origin, splitArc.second, Boolean.TRUE);

public static boolean isConnected(Digraph digraph) {
 return isConnected(digraph, digraph.vertexIterator().next(), digraph.order());
}

private void init(Digraph digraph) {
 vertexRankMap = new HashMap(digraph.order());
 IndegreeTopologicalSort traversal = new IndegreeTopologicalSort(digraph);
 while (traversal.hasNext()) {
  Object vertex = traversal.next();
  int rank = -1;
  for (ArcIterator i = digraph.incomingIterator(vertex); i.hasNext(); ) {
   i.next();
   Object predecessor = i.getOrigin();
   int predRank = intValue(predecessor);
   if (predRank < 0)
    throw new ArithmeticException("Ranking failed.");
   rank = Math.max(rank, predRank);
  }
  rank++;
  assignRank(vertex, rank);
 }
}

public boolean addVertex(Object vertex) {
 return digraph.addVertex(vertex);
}

public Object putArc(Object origin, Object destination, Object arc) {
 return digraph.putArc(destination, origin, arc);
}

public Digraph positionArcs() {
 Digraph arcGeometryDigraph = new MapDigraph();
 for (ArcIterator i = longArcDigraph.arcIterator(); i.hasNext(); ) {
  LayerVertex dummy = (LayerVertex)i.next();
  LayerVertex origin = (LayerVertex)i.getOrigin();
  y = y1 - h;
  points.add(new Point((int)x, (int)y));
  arcGeometryDigraph.putArc(origin.getUserVertex(), dst.getUserVertex(), points);

 public boolean evaluate(Object vertex) {
  return LoopSearch.this.digraph.hasArc(vertex, vertex);
 }
});

public boolean addAllVertices(Collection vertices) {
 return digraph.addAllVertices(vertices);
}