Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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.apache.pig.impl.plan;
 
 import java.util.Set;
 
This class puts everything that is needed to dump a plan in a format readable by graphviz's dot algorithm. Out of the box it does not print any nested plans.
 
 public class DotPlanDumper<E extends Operator, P extends OperatorPlan<E>, 
                            N extends Operator, S extends OperatorPlan<N>> 
     extends PlanDumper<E, P, S> {
 
     protected Set<OperatormSubgraphs;
     protected Set<OperatormMultiInputSubgraphs;    
     protected Set<OperatormMultiOutputSubgraphs;
     private boolean isSubGraph = false;
   
     public DotPlanDumper(P planPrintStream ps) {
         this(planpsfalsenew HashSet<Operator>(), new HashSet<Operator>(),
              new HashSet<Operator>());
     }
 
     protected DotPlanDumper(P planPrintStream psboolean isSubGraph
                             Set<OperatormSubgraphs
                             Set<OperatormMultiInputSubgraphs,
                             Set<OperatormMultiOutputSubgraphs) {
         super(planps);
         this. = isSubGraph;
         this. = mSubgraphs;
         this. = mMultiInputSubgraphs;
         this. = mMultiOutputSubgraphs;
     }
 
     @Override
     public void dump() {
         if (!) {
             .println("digraph plan {");
             .println("compound=true;");
             .println("node [shape=rect];");
         }
         super.dump();
         if (!) {
             .println("}");
         }
     }
 
     @Override
     protected void dumpMultiInputNestedOperator(E opMultiMap<E, S> plans) {
         dumpInvisibleOutput(op);
 
         .print("subgraph ");
         .print(getClusterID(op));
         .println(" {");
         join("; "getAttributes(op));
         .println("labelloc=b;");
         
         .add(op);
 
         for (E oplans.keySet()) {
             .print("subgraph ");
             .print(getClusterID(opo));
             .println(" {");
             .println("label=\"\";");
             dumpInvisibleInput(opo);
             for (S plan : plans.get(o)) {
                 PlanDumper dumper = makeDumper(plan);
                 dumper.dump();
                 connectInvisibleInput(opoplan);
             }
             .println("};");
         }
         .println("};");
         
         for (E oplans.keySet()) {
             for (S planplans.get(o)) {
                connectInvisibleOutput(opplan);
            }
        }
    }
    @Override 
    protected void dumpMultiOutputNestedOperator(E opCollection<S> plans) {
        super.dumpMultiOutputNestedOperator(opplans);
        .add(op);
        
        dumpInvisibleOutput(op);
        for (S planplans) {
            connectInvisibleOutput(opplan);
        }
    }
    @Override
    protected void dumpNestedOperator(E opCollection<S> plans) {
        dumpInvisibleOperators(op);
        .print("subgraph ");
        .print(getClusterID(op));
        .println(" {");
        join("; "getAttributes(op));
        .println("labelloc=b;");
        .add(op);
        
        for (S planplans) {
            PlanDumper dumper = makeDumper(plan);
            dumper.dump();
            connectInvisibleInput(opplan);
        }
        .println("};");
        for (S planplans) {
            connectInvisibleOutput(opplan);
        }
    }
    @Override
    protected void dumpOperator(E op) {
        .print(getID(op));
        .print(" [");
        join(", "getAttributes(op));
        .println("];");
    }
    @Override
    protected void dumpEdge(Operator opOperator suc) {
        String in = getID(op);
        String out = getID(suc);
        String attributes = "";
        if (.contains(op
            || .contains(op
            || .contains(op)) {
            in = getSubgraphID(opfalse);
        }
        .print(in);
        if (.contains(suc)) {
            out = getSubgraphID(sucoptrue);
            attributes = " [lhead="+getClusterID(suc,op)+"]";
        }
        if (.contains(suc)) {
            out = getSubgraphID(suctrue);
            attributes = " [lhead="+getClusterID(suc)+"]";
        }
        
        .print(" -> ");
        .print(out);
        .println(attributes);
    }
    @SuppressWarnings("unchecked")
    @Override
    protected PlanDumper makeDumper(S planPrintStream ps) {
        return new DotPlanDumper(planpstrue
                                 
                                 );
    }

    
Used to generate the label for an operator.

Parameters:
op operator to dump
    protected String getName(E op) {
        return op.name();
    }
    
    
Used to generate the the attributes of a node

Parameters:
op operator
    protected String[] getAttributes(E op) {
        String[] attributes = new String[1];
        attributes[0] =  "label=\""+getName(op)+"\"";
        return attributes;
    }
    private void connectInvisibleInput(E op1, E op2, S plan) {
        String in = getSubgraphID(op1op2true);
        
        for (N lplan.getRoots()) {
            dumpInvisibleEdge(ingetID(l));
        }
    }
    private void connectInvisibleInput(E op, S plan) {
        String in = getSubgraphID(optrue);
        for (N lplan.getRoots()) {
            String out;
            if (.contains(l) || .contains(l)) {
                out = getSubgraphID(ltrue);
            } else {
                out = getID(l);
            }
            dumpInvisibleEdge(inout);
        }
    }
    private void connectInvisibleOutput(E op
                                        OperatorPlan<? extends Operatorplan) {
        String out = getSubgraphID(opfalse);
        for (Operator lplan.getLeaves()) {
            String in;
            if (.contains(l
                || .contains(l)
                || .contains(l)) {
                in = getSubgraphID(lfalse);
            } else {
                in = getID(l);
            }
            dumpInvisibleEdge(inout);
        }
    }
    private void connectInvisible(E op, S plan) {
        connectInvisibleInput(opplan);
        connectInvisibleOutput(opplan);
    }        
    private void dumpInvisibleInput(E op1, E op2) {
        .print(getSubgraphID(op1op2true));
        .print(" ");
        .print(getInvisibleAttributes(op1));
        .println(";");
    }
    
    private void dumpInvisibleInput(E op) {
        .print(getSubgraphID(optrue));
        .print(" ");
        .print(getInvisibleAttributes(op));
        .println(";");
    }
    private void dumpInvisibleOutput(E op) {
        .print(getSubgraphID(opfalse));
        .print(" ");
        .print(getInvisibleAttributes(op));
        .println(";");
    }
    protected void dumpInvisibleOperators(E op) {
        dumpInvisibleInput(op);
        dumpInvisibleOutput(op);
    }
    private String getClusterID(Operator op1Operator op2) {
        return getClusterID(op1)+"_"+getID(op2);
    }
    private String getClusterID(Operator op) {
        return "cluster_"+getID(op);
    }
    private String getSubgraphID(Operator op1Operator op2boolean in) {
        String id = "s"+getID(op1)+"_"+getID(op2);
        if (in) {
            id += "_in";
        }
        else {
            id += "_out";
        }
        return id;
    }
    private String getSubgraphID(Operator opboolean in) {
        String id =  "s"+getID(op);
        if (in) {
            id += "_in";
        }
        else {
            id += "_out";
        }
        return id;
    }
    private String getID(Operator op) {
        return ""+Math.abs(op.hashCode());
    }
    private String getInvisibleAttributes(Operator op) {
        return "[label=\"\", style=invis, height=0, width=0]";
    }
    
    private void dumpInvisibleEdge(String opString suc) {
        .print(op);
        .print(" -> ");
        .print(suc);
        .println(" [style=invis];");
    }
New to GrepCode? Check out our FAQ X