cb.generator.GeneratorVisitor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.crazybeans Show documentation
Java library to read, modify or create Rational Rose petal files
The newest version!
/**
 * Copyright (c) 2001 Markus Dahm
 * Copyright (C) 2015-2018 BITPlan GmbH http://www.bitplan.com
 *
 * This source is part of
 * https://github.com/BITPlan/CrazyBeans
 * and the license as outlined there applies
 */
package cb.generator;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;

import cb.generator.java.Class;
import cb.generator.java.Factory;
import cb.generator.java.Field;
import cb.generator.java.Method;
import cb.generator.java.Node;
import cb.generator.java.NodeImpl;
import cb.petal.Association;
import cb.petal.Attribute;
import cb.petal.ClassAttribute;
import cb.petal.ClassCategory;
import cb.petal.DescendingVisitor;
import cb.petal.HasQuidu;
import cb.petal.Operation;
import cb.petal.PetalFile;
import cb.petal.PetalNode;
import cb.petal.PetalObject;
import cb.petal.QuidObject;
import cb.petal.RealizeRelationship;
import cb.petal.Role;
import cb.petal.UsesRelationship;
import cb.util.PiggybackVisitor;

/**
 * a Visitor that is used for generation
 * 
 * @author wf
 *
 */
public abstract class GeneratorVisitor extends DescendingVisitor implements
		Generator {

	protected static Logger LOGGER = Logger.getLogger("cb.generator");
	public static boolean debug = false;

	protected Factory factory = Factory.getInstance();
	private PiggybackVisitor visitor;
	private Map> taggedValueMap = new LinkedHashMap>();
	public Map> classesByPackage;
	public Map packagesByName = new HashMap();

	/**
	 * Where to dump the result of this generator
	 */
	private String dump;

	/**
	 * The Rose Petal file to convert
	 */
	private PetalFile tree;

	/**
	 * @return class given by quid or null if it isn't a class
	 */
	protected Class getClass(String quid) {
		Node classCandidateNode = factory.getObject(quid);
		Class clazz = null;
		if (classCandidateNode == null) {
			QuidObject obj = getTree().getQuidObject(quid);

			if (obj instanceof cb.petal.Class) {
				visit((cb.petal.Class) obj);
				clazz = (Class) factory.getObject(quid);
			}
		} else {
			if (classCandidateNode instanceof Class) {
				clazz = (Class) classCandidateNode;
			}
		}
		return clazz;
	}

	protected Class getClass(HasQuidu obj) {
		return getClass(obj.getQuidu());
	}

	/**
	 * @return containing class or null if it isn't a class
	 */
	protected Class getParentClass(PetalObject obj) {
		return getClass(((QuidObject) obj.getParent()).getQuid());
	}

	@Override
	public void visit(cb.petal.InheritanceRelationship rel) {
		Class c = getParentClass(rel);
		if (c != null)
			factory.addSuperClass(c, getClass(rel));
	}

	@Override
	public void visit(RealizeRelationship rel) {
		Class c = getParentClass(rel);
		if (c != null)
			factory.addImplementedInterface(c, getClass(rel));
	}

	@Override
	public void visit(UsesRelationship rel) {
		Class c = getParentClass(rel);
		if (c != null)
			factory.addUsedClass(c, getClass(rel), rel);
	}

	/**
	 * visit an association
	 */
	@Override
	public void visit(Association assoc) {
		Role first = assoc.getFirstRole();
		Role second = assoc.getSecondRole();
		Class class1 = getClass(first);
		Class class2 = getClass(second);

		if (class1 != null && class2 != null) {
			cb.petal.Class assc = assoc.getAssociationClass();
			Class ac = null;
			if (assc != null)
				ac = getClass(assc.getQuid());

			factory.addAssociation(class1, first, class2, second, ac);
		}
	}

	/**
	 * get the category for the given petal class
	 * 
	 * @param clazz
	 *          - the class
	 * @return - the ClassCategory
	 */
	public ClassCategory getCategory(cb.petal.Class clazz) {
		PetalNode categoryNode = clazz.getParent();
		if (categoryNode instanceof ClassCategory) {
			return (ClassCategory) categoryNode;
		} else if (categoryNode instanceof cb.petal.Class) {
			return getCategory((cb.petal.Class) categoryNode);
		} else {
			throw new RuntimeException("invalid parent for Class "
					+ clazz.getQualifiedName() + " " + categoryNode.getClass().getName());
		}

	}

	/**
	 * visit the given petal class
	 */
	public void visit(cb.petal.Class clazz) {
		String quid = clazz.getQuid();

		if (factory.getObject(quid) == null) {
			ClassCategory category = getCategory(clazz);

			cb.generator.java.Package p = addPackage(category);
			Class cl = factory.createClass(clazz, p);
			p.addClass(cl);
			factory.addObject(quid, cl);

		}
	}

	/**
	 * visit the given attribute
	 */
	@Override
	public void visit(ClassAttribute attr) {
		Field f = factory.createField(attr);
		factory.addObject(attr.getQuid(), f);
		Class c = getParentClass(attr);
		if (c != null) {
			factory.addField(c, f);
		} else {
			LOGGER.log(Level.WARNING, "missing parent class for " + attr.toString());
		}
	}

	/**
	 * visit the given operation
	 */
	@Override
	public void visit(Operation op) {
		Method m = factory.createMethod(op);
		factory.addObject(op.getQuid(), m);
		Class c = getParentClass(op);
		if (c != null) {
			factory.addMethod(c, m);
		} else {
			LOGGER.log(Level.WARNING, "");
		}
	}

	/**
	 * add a package for the given category
	 * 
	 * @param category
	 * @return the package added or retrieved
	 */
	public cb.generator.java.Package addPackage(ClassCategory category) {
		String quid = category.getQuid();
		cb.generator.java.Package p = (cb.generator.java.Package) factory
				.getObject(quid);
		// does the factory already contain this package?
		if (p == null) {
			p = factory.createPackage(category);
			this.packagesByName.put(p.getQualifiedName(), p);
			factory.addObject(category.getQuid(), p);
		}
		return p;
	}

	@Override
	public void visit(ClassCategory category) {
		addPackage(category);
	}

	/**
	 * tagged Value handling
	 */
	@Override
	public void visit(Attribute attribute) {
		// go two steps up the hierarchy - the attribute is part of a set
		// PetalObject attributeSet = (PetalObject) attribute.getParent();
		// the parent of the set is the owner ...
		PetalNode parent = attribute.getParent();
		if (parent instanceof QuidObject) {
			QuidObject parentquidObj = (QuidObject) parent;
			String quid = parentquidObj.getQuid();
			if (debug)
				LOGGER.log(Level.INFO, "parent for attribute is "
						+ parent.getClass().getName() + "(" + quid + ")");
			List attrs = null;
			if (taggedValueMap.containsKey(quid)) {
				attrs = taggedValueMap.get(quid);
			} else {
				attrs = new ArrayList();
				taggedValueMap.put(quid, attrs);
			}
			attrs.add(attribute);
		} else {
			if (debug)
				LOGGER.log(Level.INFO, "parent for attribute is "
						+ parent.getClass().getName());
		}
	}

	/**
	 * @return the dump
	 */
	@Override
	public String getDumpPath() {
		return dump;
	}

	/**
	 * @param dump
	 *          the dump to set
	 */
	@Override
	public void setDumpPath(String dump) {
		this.dump = dump;
	}

	/**
	 * @return the tree
	 */
	@Override
	public PetalFile getTree() {
		return tree;
	}

	/**
	 * @param tree
	 *          the tree to set
	 */
	@Override
	public void setTree(PetalFile tree) {
		this.tree = tree;
	}

	@Override
	public void init() {
		visitor = new PiggybackVisitor(this);
	}

	@Override
	public void start() throws Exception {
		getTree().accept(visitor);
		// pass2 tagged Value handling
		for (Entry> taggedValueEntry : taggedValueMap
				.entrySet()) {
			String quid = taggedValueEntry.getKey();
			NodeImpl node = (NodeImpl) factory.getObject(quid);
			if (node != null)
				node.addTaggedValues(taggedValueEntry.getValue());
		}
	}

	/**
	 * default run method
	 */
	@Override
	public void run() throws Exception {
		init();
		start();
		dump();
	}

}