bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/types/TUnion.java

   1 package org.simantics.scl.compiler.types;
   2
   3 import gnu.trove.map.hash.THashMap;
   4 import gnu.trove.set.hash.THashSet;
   5
   6 import java.util.ArrayList;
   7
   8 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
   9 import org.simantics.scl.compiler.internal.types.TypeHashCodeContext;
  10 import org.simantics.scl.compiler.internal.types.ast.TConAst;
  11 import org.simantics.scl.compiler.internal.types.ast.TypeAst;
  12 import org.simantics.scl.compiler.types.util.Polarity;
  13 import org.simantics.scl.compiler.types.util.TypeUnparsingContext;
  14
  15 public class TUnion extends Type {
  16     public final Type[] effects;
  17
  18     public TUnion(Type ... effects) {
  19         if(NULL_CHECKS) {
  20             for(Type effect : effects)
  21                 if(effect == null)
  22                     throw new InternalCompilerError();
  23         }
  24         this.effects = effects;
  25     }
  26
  27     @Override
  28     public Type replace(TVar var, Type replacement) {
  29         for(int i=0;i<effects.length;++i) {
  30             Type effect = effects[i];
  31             Type newEffect = effect.replace(var, replacement);
  32             if(newEffect != effect) {
  33                 Type[] newEffects = new Type[effects.length];
  34                 for(int j=0;j<i;++j)
  35                     newEffects[j] = effects[j];
  36                 newEffects[i] = newEffect;
  37                 for(int j=i+1;j<effects.length;++j)
  38                     newEffects[j] = effects[j].replace(var, replacement);
  39                 return new TUnion(newEffects);
  40             }
  41         }
  42         return this;
  43     }
  44
  45     @Override
  46     public TypeAst toTypeAst(TypeUnparsingContext context) {
  47         StringBuilder b = new StringBuilder();
  48         //b.append("#");
  49         for(int i=0;i<effects.length;++i) {
  50             if(i > 0)
  51                 b.append(",");
  52             b.append(effects[i].toString(context));
  53         }
  54         //b.append("#");
  55         return new TConAst(b.toString());
  56     }
  57
  58     @Override
  59     public void toName(TypeUnparsingContext context, StringBuilder b) {
  60         boolean first = true;
  61         for(Type effect : effects) {
  62             if(first)
  63                 first = false;
  64             else
  65                 b.append('_');
  66             effect.toName(context, b);
  67         }
  68     }
  69
  70     @Override
  71     public void updateHashCode(TypeHashCodeContext context) {
  72         context.append(TypeHashCodeContext.UNION);
  73         for(Type effect : effects)
  74             effect.updateHashCode(context);
  75     }
  76
  77     @Override
  78     public void collectFreeVars(ArrayList<TVar> vars) {
  79         for(Type effect : effects)
  80             effect.collectFreeVars(vars);
  81     }
  82
  83     @Override
  84     public void collectMetaVars(ArrayList<TMetaVar> vars) {
  85         for(Type effect : effects)
  86             effect.collectMetaVars(vars);
  87     }
  88
  89     @Override
  90     public void collectMetaVars(THashSet<TMetaVar> vars) {
  91         for(Type effect : effects)
  92             effect.collectMetaVars(vars);
  93     }
  94
  95     @Override
  96     public boolean isGround() {
  97         for(Type effect : effects)
  98             if(!effect.isGround())
  99                 return false;
 100         return true;
 101     }
 102
 103     @Override
 104     public boolean containsMetaVars() {
 105         for(Type effect : effects)
 106             if(effect.containsMetaVars())
 107                 return true;
 108         return false;
 109     }
 110
 111     @Override
 112     public int getClassId() {
 113         return UNION_ID;
 114     }
 115
 116     @Override
 117     public boolean contains(TMetaVar other) {
 118         for(Type type : effects)
 119             if(type.contains(other))
 120                 return true;
 121         return false;
 122     }
 123
 124     @Override
 125     public Type convertMetaVarsToVars() {
 126         for(int i=0;i<effects.length;++i)
 127             effects[i] = effects[i].convertMetaVarsToVars();
 128         return this;
 129     }
 130
 131     @Override
 132     public boolean isMinimal() {
 133         return effects.length == 0;
 134     }
 135
 136     @Override
 137     public boolean isMaximal() {
 138         return false;
 139     }
 140
 141     @Override
 142     public void addPolarity(Polarity polarity) {
 143         for(Type effect : effects)
 144             effect.addPolarity(polarity);
 145     }
 146
 147     @Override
 148     public void collectEffectMetaVars(ArrayList<TMetaVar> vars) {
 149         throw new UnsupportedOperationException();
 150     }
 151
 152     @Override
 153     public void collectConcreteEffects(ArrayList<TCon> concreteEffects) {
 154         for(Type effect : effects)
 155             effect.collectConcreteEffects(concreteEffects);
 156     }
 157
 158     @Override
 159     public Type head() {
 160         throw new UnsupportedOperationException();
 161     }
 162
 163     @Override
 164     public Type copySkeleton(THashMap<TMetaVar, TMetaVar> metaVarMap) {
 165         return Types.NO_EFFECTS;
 166     }
 167 }