org.openprovenance.prov.generator.Tree Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of prov-generator Show documentation
A random generator of PROV graphs.
There is a newer version: 2.1.1
/*
 * Copyright 2007 Google Inc.
 *
 * 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.openprovenance.prov.generator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

/**
  * @author [email protected] (Yohann Coppel)
  * 
  * @param 
  *          Object's type in the tree.
*/
public class Tree {

  private T head;

  private ArrayList> leafs = new ArrayList>();

  private Tree parent = null;

  private HashMap> locate = new HashMap>();

  public Tree(T head) {
    this.head = head;
    locate.put(head, this);
  }

  public void addLeaf(T root, T leaf) {
    if (locate.containsKey(root)) {
      locate.get(root).addLeaf(leaf);
    } else {
      addLeaf(root).addLeaf(leaf);
    }
  }

  public Tree addLeaf(T leaf) {
    Tree t = new Tree(leaf);
    leafs.add(t);
    t.parent = this;
    t.locate = this.locate;
    locate.put(leaf, t);
    return t;
  }

  public Tree setAsParent(T parentRoot) {
    Tree t = new Tree(parentRoot);
    t.leafs.add(this);
    this.parent = t;
    t.locate = this.locate;
    t.locate.put(head, this);
    t.locate.put(parentRoot, t);
    return t;
  }

  public T getHead() {
    return head;
  }

  public Tree getTree(T element) {
    return locate.get(element);
  }

  public Tree getParent() {
    return parent;
  }

  public Collection getSuccessors(T root) {
    Collection successors = new ArrayList();
    Tree tree = getTree(root);
    if (null != tree) {
      for (Tree leaf : tree.leafs) {
        successors.add(leaf.head);
      }
    }
    return successors;
  }

  public Collection> getSubTrees() {
    return leafs;
  }

  public static  Collection getSuccessors(T of, Collection> in) {
    for (Tree tree : in) {
      if (tree.locate.containsKey(of)) {
        return tree.getSuccessors(of);
      }
    }
    return new ArrayList();
  }

  @Override
  public String toString() {
    return printTree(0);
  }

  private static final int indent = 2;

  private String printTree(int increment) {
    String s = "";
    String inc = "";
    for (int i = 0; i < increment; ++i) {
      inc = inc + " ";
    }
    s = inc + head;
    for (Tree child : leafs) {
      s += "\n" + child.printTree(increment + indent);
    }
    return s;
  }
  
  /*public boolean contains(T element, T head){
	 if(element.equals(head)) return true;
	 Collection suc = getSuccessors(head);
	 for (T child : suc) {
			 contains(element, child);
	 }
	 return false;
  }*/
}