001/*
002 * Copyright (c) 2016 Chris K Wensel <chris@wensel.net>. All Rights Reserved.
003 * Copyright (c) 2007-2017 Xplenty, Inc. All Rights Reserved.
004 *
005 * Project and contact information: http://www.cascading.org/
006 *
007 * This file is part of the Cascading project.
008 *
009 * Licensed under the Apache License, Version 2.0 (the "License");
010 * you may not use this file except in compliance with the License.
011 * You may obtain a copy of the License at
012 *
013 *     http://www.apache.org/licenses/LICENSE-2.0
014 *
015 * Unless required by applicable law or agreed to in writing, software
016 * distributed under the License is distributed on an "AS IS" BASIS,
017 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
018 * See the License for the specific language governing permissions and
019 * limitations under the License.
020 */
021
022package cascading.flow.planner.iso.transformer;
023
024import java.io.File;
025import java.util.LinkedList;
026import java.util.List;
027
028import cascading.flow.planner.PlannerContext;
029import cascading.flow.planner.graph.ElementGraph;
030import cascading.flow.planner.graph.ElementMultiGraph;
031import cascading.flow.planner.iso.GraphResult;
032import cascading.flow.planner.iso.expression.ExpressionGraph;
033import cascading.flow.planner.rule.Rule;
034
035/**
036 *
037 */
038public class Transformed<E extends ElementGraph> extends GraphResult
039  {
040  PlannerContext plannerContext;
041  GraphTransformer graphTransformer;
042  ExpressionGraph expressionGraph;
043  ElementGraph beginGraph;
044  int recursionCount = 0;
045  List<ElementGraph> recursions;
046  List<Transformed> childTransforms;
047  E endGraph;
048
049  public Transformed( PlannerContext plannerContext, GraphTransformer graphTransformer, ElementGraph beginGraph )
050    {
051    this.plannerContext = plannerContext;
052    this.graphTransformer = graphTransformer;
053
054    if( plannerContext.isTransformTracingEnabled() )
055      beginGraph = new ElementMultiGraph( beginGraph );
056
057    this.beginGraph = beginGraph;
058    }
059
060  public Transformed( PlannerContext plannerContext, GraphTransformer graphTransformer, ExpressionGraph expressionGraph, ElementGraph beginGraph )
061    {
062    this.plannerContext = plannerContext;
063    this.graphTransformer = graphTransformer;
064    this.expressionGraph = expressionGraph;
065
066    if( plannerContext.isTransformTracingEnabled() )
067      beginGraph = new ElementMultiGraph( beginGraph );
068
069    this.beginGraph = beginGraph;
070    }
071
072  public PlannerContext getPlannerContext()
073    {
074    return plannerContext;
075    }
076
077  public String getRuleName()
078    {
079    if( getGraphTransform() instanceof Rule )
080      return ( (Rule) getGraphTransform() ).getRuleName();
081
082    return "none";
083    }
084
085  public String getTransformerName()
086    {
087    return getGraphTransform().getClass().getSimpleName();
088    }
089
090  public GraphTransformer getGraphTransform()
091    {
092    return graphTransformer;
093    }
094
095  @Override
096  public ElementGraph getBeginGraph()
097    {
098    return beginGraph;
099    }
100
101  public void setEndGraph( E endGraph )
102    {
103    this.endGraph = endGraph;
104    }
105
106  @Override
107  public E getEndGraph()
108    {
109    return endGraph;
110    }
111
112  public int getNumRecursions()
113    {
114    return recursionCount;
115    }
116
117  public List<ElementGraph> getRecursions()
118    {
119    if( recursions == null )
120      recursions = new LinkedList<>();
121
122    return recursions;
123    }
124
125  public List<Transformed> getChildTransforms()
126    {
127    if( childTransforms == null )
128      childTransforms = new LinkedList<>();
129
130    return childTransforms;
131    }
132
133  void addRecursionTransform( ElementGraph transformed )
134    {
135    recursionCount++;
136
137    if( plannerContext.isTransformTracingEnabled() )
138      getRecursions().add( new ElementMultiGraph( transformed ) );
139    }
140
141  public void addChildTransform( Transformed transformed )
142    {
143    if( plannerContext.isTransformTracingEnabled() )
144      getChildTransforms().add( transformed );
145    }
146
147  @Override
148  public void writeDOTs( String path )
149    {
150    int count = 0;
151
152    if( expressionGraph != null )
153      {
154      String fileName = String.format( "expression-graph-%s.dot", expressionGraph.getClass().getSimpleName() );
155      expressionGraph.writeDOT( new File( path, fileName ).toString() );
156      }
157
158    for( int i = 0; i < getChildTransforms().size(); i++ )
159      {
160      Transformed transformed = getChildTransforms().get( i );
161      String name = transformed.getTransformerName();
162      String pathName = String.format( "%s/child-%d-%s/", path, i, name );
163      transformed.writeDOTs( pathName );
164      }
165
166    count = writeBeginGraph( path, count );
167
168    for( ElementGraph recursion : getRecursions() )
169      {
170      String name = recursion.getClass().getSimpleName();
171      recursion.writeDOT( new File( path, makeFileName( count++, name, "recursion" ) ).toString() );
172      }
173
174    writeEndGraph( path, count );
175    }
176  }