import edu.neu.ccs.demeter.dj.*;
import java.util.*;
import edu.neu.ccs.demeter.*;
 class Cd_graph {
  protected GlobalImports globalimports;
  public GlobalImports get_globalimports() { return globalimports;   }
  public void set_globalimports(GlobalImports new_globalimports) { globalimports = new_globalimports;   }
  protected Adjacency_Nlist adjacencies;
  public Adjacency_Nlist get_adjacencies() { return adjacencies;   }
  public void set_adjacencies(Adjacency_Nlist new_adjacencies) { adjacencies = new_adjacencies;   }
  public Cd_graph() { super();   }
  public Cd_graph(GlobalImports globalimports, Adjacency_Nlist adjacencies) {
    super();
    set_globalimports(globalimports);
    set_adjacencies(adjacencies);
    }
  public static Cd_graph parse(java.io.Reader in) throws ParseException { return new Parser(in)._Cd_graph();   }
  public static Cd_graph parse(java.io.InputStream in) throws ParseException { return new Parser(in)._Cd_graph();   }
  public static Cd_graph parse(String s) {
    try { return parse(new java.io.StringReader(s)); }
    catch (ParseException e) {
      throw new RuntimeException(e.toString());
    }
    }
   void display() {
    DisplayVisitor v0 = new DisplayVisitor();
    v0.start();
    __trav_display(v0);
    v0.finish();
    }
   boolean checkUndefined(ClassGraph cg) {
		System.out.println("Checking for Undefined Classes. . .");
		return checkDefined(cg, getClasses(cg));
	  }
   HashSet getClasses(ClassGraph cg) {
		Strategy getAll = new Strategy("from Cd_graph bypassing Neighbors to Vertex");
		TraversalGraph tg = new TraversalGraph(getAll, cg);
		return (HashSet)tg.traverse(this, new Visitor(){
							HashSet return_val  = new HashSet();
							void before(Vertex v){
								return_val.add(v.get_vertex_name());	
							}
							public Object getReturnValue(){
								return return_val;
							}
						});		
	  }
   boolean checkDefined(ClassGraph cg, HashSet tempClassSet) {
		final HashSet classHash = tempClassSet;
		Strategy checkAll = new Strategy("from Cd_graph through Neighbors to Vertex");
		TraversalGraph tg = new TraversalGraph(checkAll, cg);
		return ((Boolean)tg.traverse(this, new Visitor(){
					boolean return_val = true;
					void before(Vertex v){
						if(!classHash.contains(v.get_vertex_name())){
							System.out.println("ERROR: The class "+
							v.get_vertex_name() + " is undefined.");
							return_val = false;
						}
					}
					public Object getReturnValue(){
						return new Boolean(return_val);
					}
				  }

				    )).booleanValue();
	  }
   void checkUnique(ClassGraph _cg) {
		flatten(_cg);
		final ClassGraph cg = _cg;
		System.out.println("Checking for Unique Parts violations. . .");
		Strategy getAllParts = new Strategy("from Cd_graph to Adjacency");
		TraversalGraph tg = new TraversalGraph(getAllParts, cg);
		tg.traverse(this, new Visitor(){
				void before(Adjacency a){
					a.checkDuplicateParts(cg);
					}
				});
		
	  }
   void checkInheritanceCycle(ClassGraph cg) {
		if(checkMultiInheritance(cg) == true){
			System.out.println("Checking for Inheritance Cycle violations. . .");
			Strategy st = new Strategy("from Cd_graph via Alternat_ns to Vertex");
			TraversalGraph tg = new TraversalGraph(st, cg);
			tg.traverse(this, new Visitor(){
						Ident tempSource;
						Ident currentChild;
						Ident tempChild;
						String iCycle = new String();
						HashMap hClasses = new HashMap();
						void before(Adjacency ad){
							tempSource = ad.get_source().get_vertex_name();
						}
						void before(Alternat_ns alt){
							Enumeration eChildren = alt.get_alternat_ns().elements();
							while(eChildren.hasMoreElements()){
								currentChild = ((Term)eChildren.nextElement()).
										get_vertex().get_vertex_name();
								if(false == hClasses.containsValue(currentChild)){
									hClasses.put(currentChild, tempSource);
								}
								else{
									iCycle += ("Inheritance cycle exists from " + tempSource);
									while(tempSource != null){
										tempChild = tempSource;				
										tempSource = (Ident)hClasses.get(tempChild);
										if(tempSource != null){
											iCycle += (" to " + tempSource);
										}
										else{
											System.out.println(iCycle);
											iCycle = "";
										}
									}
								}
							}
						}
						}
					);	
		}
	  }
   void flatten(ClassGraph cg) {
		Strategy sg = new Strategy("from Cd_graph to Neighbors_wc");
		TraversalGraph tg = new TraversalGraph(sg, cg);
		if(checkUndefined(cg) == true){
			System.out.println("Flattening ClassGraph. . .");
			tg.traverse(this, new Visitor(){
					Any_vertex_List common;
					Ident currentSource;
					HashMap adjacency_wc = new HashMap();
					void before(Adjacency adj){
						currentSource = adj.get_source().get_vertex_name();
					}
					void before(Neighbors_wc neighbor){
						common = neighbor.get_construct_ns();
						if(adjacency_wc.containsKey(currentSource)){
							Any_vertex_List tempList = (Any_vertex_List)adjacency_wc.get(currentSource);
							while(tempList.hasMoreElements()){
								common.addElement((Any_vertex)tempList.nextElement());
							}
							neighbor.set_construct_ns(common);
						}
					}
					void before(Alternat_ns alt){
						Enumeration en = alt.get_alternat_ns().elements();
						while(en.hasMoreElements()){
							adjacency_wc.put(((Term)en.nextElement()).
									  get_vertex().get_vertex_name(),common);
						}
					}
					}
			    );
		}
	  }
   boolean checkMultiInheritance(ClassGraph cg) {
		System.out.println("Checking for Multiple Inheritance violations. . .");
		Strategy sg = new Strategy("from Cd_graph to Alternat_ns");
		TraversalGraph tg = new TraversalGraph(sg, cg);
		return ((Boolean)tg.traverse(this, new Visitor(){
								Ident currentSource;
								Ident currentChild;
								LinkedList lHasMultiParents = new LinkedList();
								boolean return_val = true;
								HashMap hChildren = new HashMap();
								void before(Adjacency adj){
									currentSource = adj.get_source().get_vertex_name();
								}
								void before(Alternat_ns alt){
									Enumeration en = alt.get_alternat_ns().elements();
									while(en.hasMoreElements()){
										currentChild = ((Term)en.nextElement()).get_vertex().
												get_vertex_name();
										if(hChildren.containsKey(currentChild)){
											((LinkedList)hChildren.get(currentChild)).
														add(currentSource);
											lHasMultiParents.add(currentChild);
											return_val = false;
										}
										else{
											LinkedList tempParentList = new LinkedList();
											tempParentList.add(currentSource);
											hChildren.put(currentChild, tempParentList);
										}
									}
								}
								void after(Cd_graph cd){
									LinkedList lParents;
									Ident tempChild;
									String output;
									while(lHasMultiParents.size() != 0){
										tempChild = (Ident)lHasMultiParents.removeFirst();
										output = "ERROR: Element " + tempChild + " inherits from: ";
										lParents = (LinkedList)hChildren.get(tempChild);
										while(lParents.size() != 0){
											output += lParents.removeFirst() + ", ";
										}
										System.out.println(output);
									}
								}
								public Object getReturnValue(){
									return new Boolean(return_val);
								}	
				       			}
			    			)).booleanValue();
	  }
   void checkTerminalBuff(ClassGraph cg) {
		flatten(cg);
		System.out.println("Checking for Terminal Buffer violations. . .");
		Strategy sg = new Strategy("from Cd_graph to Opt_labeled_term");
		TraversalGraph tg = new TraversalGraph(sg, cg);
		tg.traverse(this, 
			new Visitor(){
				int numTerminalBuff = 0;
				LinkedList lViolations = new LinkedList();
				void before(Opt_labeled_term optLabeled){
					String className = optLabeled.get_vertex().get_vertex().
							   get_vertex_name().toString();
					if(optLabeled.isKnownTerminal(className)){
						numTerminalBuff++;
						lViolations.add(className);
					}
				}
				void after(Adjacency adj){
					if(numTerminalBuff > 0){
						Ident currentSource = adj.get_source().get_vertex_name();
						String output =  "WARNING: Class " + currentSource +
								 " violates terminal buffer rule: \n";
						while(lViolations.size() != 0){
							output += (String)lViolations.removeFirst() + " is not "+
								  "the only part of the class.\n";
						}	
						numTerminalBuff = 0;
						System.out.print(output);
					}
				}
			});
	  }
    void universal_trv0_bef(UniversalVisitor _v_) {
    ((UniversalVisitor) _v_).before(this);
  }

    void universal_trv0_aft(UniversalVisitor _v_) {
    ((UniversalVisitor) _v_).after(this);
  }

    void universal_trv0(UniversalVisitor _v_) {
    universal_trv0_bef(_v_);
    ((UniversalVisitor) _v_).before_globalimports(this, globalimports);
    globalimports.universal_trv0(_v_);
    ((UniversalVisitor) _v_).after_globalimports(this, globalimports);
    ((UniversalVisitor) _v_).before_adjacencies(this, adjacencies);
    adjacencies.universal_trv0(_v_);
    ((UniversalVisitor) _v_).after_adjacencies(this, adjacencies);
    universal_trv0_aft(_v_);
  }

    public void __trav_display(DisplayVisitor __v0) {
    __trav_display_Cd_graph_trv(__v0);
  }

    void __trav_display_Cd_graph_trv_bef(DisplayVisitor __v0) {
    ((DisplayVisitor) __v0).before(this);
  }

    void __trav_display_Cd_graph_trv_aft(DisplayVisitor __v0) {
    ((DisplayVisitor) __v0).after(this);
  }

    void __trav_display_Cd_graph_trv(DisplayVisitor __v0) {
    __trav_display_Cd_graph_trv_bef(__v0);
    ((DisplayVisitor) __v0).before_globalimports(this, globalimports);
    globalimports.__trav_display_Cd_graph_trv(__v0);
    ((UniversalVisitor) __v0).after_globalimports(this, globalimports);
    ((DisplayVisitor) __v0).before_adjacencies(this, adjacencies);
    adjacencies.__trav_display_Cd_graph_trv(__v0);
    ((UniversalVisitor) __v0).after_adjacencies(this, adjacencies);
    __trav_display_Cd_graph_trv_aft(__v0);
  }

}