2.4/dev/core/src/com/google/gwt/dev/jjs/impl/gflow/CombinedIntegratedAnalysis.java

/*
 * Copyright 2009 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 com.google.gwt.dev.jjs.impl.gflow;

import com.google.gwt.dev.jjs.impl.gflow.TransformationFunction.Transformation;
import com.google.gwt.dev.util.Preconditions;

import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;

/**
 * Integrated analysis, which combines several other integrated analyses into
 * one. It does so be defining combined assumption, which is vector of original
 * assumptions, and applies each analysis to its own component.
 * 
 * If any analysis decides to rewrite the node, combined analysis returns
 * produced transformation. If more than one analyses decide to transform, the
 * first one wins.
 * 
 * @param <N> graph node type.
 * @param <E> graph edge type.
 * @param <T> graph transformer type.
 * @param <G> graph type.
 * 
 */
public class CombinedIntegratedAnalysis<N, E, T, G extends Graph<N, E, T>>
    implements
    IntegratedAnalysis<N, E, T, G, CombinedIntegratedAnalysis.CombinedAssumption> {

  /**
   * Combined assumption which holds vector of original assumptions.
   */
  public static class CombinedAssumption implements
      Assumption<CombinedAssumption> {
    
    private static class CopyOnWrite {
      private final int size;
      private CombinedAssumption assumption;
      private boolean copied = false;
      
      private CopyOnWrite(CombinedAssumption assumption, int size) {
        this.assumption = assumption;
        this.size = size;
      }

      public boolean isCopied() {
        return copied;
      }

      public void set(int slice, Assumption<?> assumption) {
        copyIfNeeded();
        this.assumption.set(slice, assumption);
      }

      public CombinedAssumption unwrap() {
        return assumption;
      }

      private void copyIfNeeded() {
        if (!copied) {
          copied = true;
          if (assumption == null) {
            assumption = new CombinedAssumption(size);
          } else {
            assumption = new CombinedAssumption(assumption);
          }
        }
      }
    }

    /**
     * Individual assumptions vector.
     */
    private final List<Assumption<?>> assumptions;

    public CombinedAssumption(CombinedAssumption assumption) {
      this.assumptions = new ArrayList<Assumption<?>>(assumption.assumptions);
    }

    public CombinedAssumption(int size) {
      this.assumptions = new ArrayList<Assumption<?>>(size);
      for (int i = 0; i < size; ++i) {
        this.assumptions.add(null);
      }
    }

    public CombinedAssumption(List<Assumption<?>> assumptions) {
      this.assumptions = assumptions;
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      }
      if (obj == null) {
        return false;
      }

      CombinedAssumption other = (CombinedAssumption) obj;

      // We do not implement equals in our zipped lists. Do it here.
      if (other.assumptions.size() != assumptions.size()) {
        return false;
      }
      
      for (int i = 0; i < assumptions.size(); ++i) {
        Assumption<?> a1 = assumptions.get(i);
        Assumption<?> a2 = other.assumptions.get(i);
        if (a1 == null) {
          if (a1 != a2) {
            return false;
          }
        } else {
          if (a2 == null) {
            return false;
          }
          if (!a1.equals(a2)) {
            return false;
          }
        } 
      }
      
      return true;
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result
          + ((assumptions == null) ? 0 : assumptions.hashCode());
      return result;
    }

    /**
     * Joins combined assumption by joining all individual components.
     */
    @SuppressWarnings("unchecked")
    public CombinedAssumption join(CombinedAssumption value) {
      if (value == null) {
        return this;
      }
      Preconditions.checkArgument(value.assumptions.size() == 
        assumptions.size());
      
      List<Assumption<?>> newAssumptions = new ArrayList<Assumption<?>>();
      for (int i = 0; i < assumptions.size(); ++i) {
        Assumption a1 = assumptions.get(i);
        Assumption a2 = value.assumptions.get(i);
        newAssumptions.add(AssumptionUtil.join(a1, a2));
      }

      return new CombinedAssumption(newAssumptions);
    }

    @Override
    public String toString() {
      return assumptions.toString();
    }

    /**
     * Gets nth assumption component.
     */
    private Assumption<?> get(int n) {
      return assumptions.get(n);
    }

    private void set(int slice, Assumption<?> assumption) {
      assumptions.set(slice, assumption);
    }
  }

  /**
   * Combined integrated flow function.
   */
  private final class CombinedIntegratedFlowFunction implements
      IntegratedFlowFunction<N, E, T, G, CombinedAssumption> {
    @SuppressWarnings("unchecked")
    public Transformation interpretOrReplace(final N node, final G graph,
        final AssumptionMap<E, CombinedAssumption> assumptionMap) {
      
      final Map<E, CombinedAssumption.CopyOnWrite> newAssumptions = new IdentityHashMap<E, CombinedAssumption.CopyOnWrite>();
      
      final int size = functions.size();
      for (int i = 0; i < size; ++i) {
        final int slice = i;
        IntegratedFlowFunction function = functions.get(i);
        
        Transformation transformation = 
          function.interpretOrReplace(node, graph, 
              new AssumptionMap() {
                public Assumption getAssumption(Object edge) {
                  CombinedAssumption combinedAssumption = assumptionMap.getAssumption((E) edge);
                  if (combinedAssumption == null) {
                    return null;
                  }
                  return combinedAssumption.get(slice);
                }

                public void setAssumption(Object edge, Assumption assumption) {
                  CombinedAssumption.CopyOnWrite newAssumption = newAssumptions.get(edge);
                  if (newAssumption == null) {
                    newAssumption = new CombinedAssumption.CopyOnWrite(assumptionMap.getAssumption((E) edge), size);
                    newAssumptions.put((E) edge, newAssumption);
                  }
                  newAssumption.set(slice, assumption);
                }

                @Override
                public String toString() {
                  return AssumptionUtil.toString(graph.getInEdges(node), 
                      graph.getOutEdges(node), this);
                }
              });
        
        if (transformation != null) {
          return transformation;
        }
      }

      for (E e : newAssumptions.keySet()) {
        CombinedAssumption.CopyOnWrite newAssumption = newAssumptions.get(e);
        if (newAssumption.isCopied()) {
          assumptionMap.setAssumption(e, newAssumption.unwrap());
        }
      }
      
      return null;
    }
  }

  /**
   * Factory method. 
   */
  public static <N, E, T, G extends Graph<N, E, T>> 
  CombinedIntegratedAnalysis<N, E, T, G> createAnalysis() {
    return new CombinedIntegratedAnalysis<N, E, T, G>();
  }
  /**
   * Individual analyses.
   */
  List<IntegratedAnalysis<N, E, T, G, ?>> analyses = 
    new ArrayList<IntegratedAnalysis<N, E, T, G, ?>>();

  /**
   * Their flow functions.
   */
  List<IntegratedFlowFunction<N, E, T, G, ?>> functions = 
    new ArrayList<IntegratedFlowFunction<N, E, T, G, ?>>();

  /**
   * Adds analysis to the combined one.
   */
  public void addAnalysis(IntegratedAnalysis<N, E, T, G, ?> analysis) {
    analyses.add(analysis);
    functions.add(analysis.getIntegratedFlowFunction());
  }

  public IntegratedFlowFunction<N, E, T, G, CombinedAssumption> 
  getIntegratedFlowFunction() {
    return new CombinedIntegratedFlowFunction();
  }
  
  @SuppressWarnings("unchecked")
  public void setInitialGraphAssumptions(G graph,
      final AssumptionMap<E, CombinedAssumption> assumptionMap) {
    for (int i = 0; i < functions.size(); ++i) {
      final int slice = i;
      IntegratedAnalysis<N, E, T, G, ?> analysis = analyses.get(slice);
      analysis.setInitialGraphAssumptions(graph, new AssumptionMap() {
        public Assumption getAssumption(Object edge) {
          throw new UnsupportedOperationException();
        }

        public void setAssumption(Object edge,Assumption assumption) {
          CombinedAssumption combinedAssumption = assumptionMap.getAssumption((E) edge);
          if (combinedAssumption == null) {
            combinedAssumption = new CombinedAssumption(functions.size());
            combinedAssumption.set(slice, assumption);
            assumptionMap.setAssumption((E) edge, combinedAssumption);
          } else {
            combinedAssumption.set(slice, assumption);
          }
        }
      });
    }
  }
}