How to use

addVertex

method

in

org.objectstyle.ashwood.graph.Digraph

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

public Object createNode(GraphmlContext context, String id) {
  Digraph digraph = (Digraph) context.getGraph();
  digraph.addVertex(id);
  return id;
}

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 void build(Digraph digraph) {
 for (Iterator i = graphData.entrySet().iterator(); i.hasNext();) {
  Map.Entry entry = (Map.Entry)i.next();
  Object origin = vertexAccessor.create(entry.getKey());
  digraph.addVertex(origin);
  StringTokenizer st = new StringTokenizer((String)entry.getValue(), ";");
  while (st.hasMoreTokens()) {
   digraph.putArc(origin, vertexAccessor.create(st.nextToken()), Boolean.TRUE);
  }
 }
}

public static Digraph randomizeTree(Digraph digraph, int maxChildren, int maxLevels, Random randomizer) {
 int vertexIndex = 1;
 Object root = new Integer(vertexIndex);
 List level = Collections.singletonList(root);
 digraph.addVertex(root);
 for (int i = 1; i < maxLevels; i++) {
  List childLevel = new ArrayList(level.size() * maxChildren);
  for (Iterator j = level.iterator(); j.hasNext(); ) {
   Object parent = j.next();
   int childCount = randomizer.nextInt(maxChildren + 1);
   for (int k = 0; k < childCount; k++) {
    Object child = new Integer(++vertexIndex);
    digraph.addVertex(child);
    digraph.putArc(parent, child, Boolean.TRUE);
    childLevel.add(child);
   }
  }
  if (childLevel.isEmpty()) break;
  level = childLevel;
 }
 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;
}

  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;
  }
}

contractedDigraph.addVertex(origin);
for (Iterator j = origin.iterator(); j.hasNext();) {
 Object member = j.next();

public static Digraph merge(Digraph destination,DigraphIteration graphToMerge) {
 for (Iterator i = graphToMerge.vertexIterator(); i.hasNext();) {
  destination.addVertex(i.next());
 }
 for (ArcIterator i = graphToMerge.arcIterator(); i.hasNext();) {
  Object arc = i.next();
  Object origin = i.getOrigin();
  Object dst = i.getDestination();
  destination.putArc(origin, dst, arc);
 }
 return destination;
}

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);
  }
}

Table table = generateTable(vertex, graph);
vertexToTable.put(vertex, table);
schemaGraph.addVertex(table);

public static Digraph transform(Digraph result,
                DigraphIteration source,
                Transformer vertexTransform,
                Transformer arcTransform) {
 for (Iterator i = new TransformIterator(source.vertexIterator(), vertexTransform);
    i.hasNext();) {
  result.addVertex(i.next());
 }
 for (ArcIterator i = new TransformArcIterator(source.arcIterator(), vertexTransform, arcTransform);
    i.hasNext();) {
  Object arc = i.next();
  Object origin = i.getOrigin();
  Object dst = i.getDestination();
  result.putArc(origin, dst, arc);
 }
 return result;
}

NestingTreeNode origin = v1.getParentSubgraph();
NestingTreeNode dst = v2.getParentSubgraph();
subgraphOrderingGraph.addVertex(origin);
subgraphOrderingGraph.addVertex(dst);
if (origin == dst) continue;
if (origin == root) origin = v1;

for (int i = 0; i < size; i++) {
  DataObject current = (DataObject) objects.get(i);
  objectDependencyGraph.addVertex(current);
  int actualMasterCount = 0;
  for (int k = 0; k < reflexiveRelNames.length; k++) {

for (int i = 0; i < size; i++) {
  DataObject current = (DataObject) objects.get(i);
  objectDependencyGraph.addVertex(current);
  int actualMasterCount = 0;
  for (int k = 0; k < reflexiveRelNames.length; k++) {