bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/environment/filter/NamespaceFilters.java

   1 package org.simantics.scl.compiler.environment.filter;
   2
   3 import org.simantics.scl.compiler.elaboration.expressions.EVar;
   4 import org.simantics.scl.compiler.module.ImportDeclaration.ImportSpec;
   5
   6 import gnu.trove.set.hash.THashSet;
   7
   8 public class NamespaceFilters {
   9     public static NamespaceFilter createFromSpec(ImportSpec spec) {
  10         if(spec.hiding) {
  11             if(spec.values.length == 0)
  12                 return AcceptAllNamespaceFilter.INSTANCE;
  13             THashSet<String> names = new THashSet<String>(spec.values.length);
  14             for(EVar value : spec.values)
  15                 names.add(value.name);
  16             return new NegativeNamespaceFilter(names);
  17         }
  18         else {
  19             THashSet<String> names = new THashSet<String>(spec.values.length);
  20             for(EVar value : spec.values)
  21                 names.add(value.name);
  22             return new PositiveNamespaceFilter(names);
  23         }
  24     }
  25
  26     public static NamespaceFilter union(NamespaceFilter a, NamespaceFilter b) {
  27         if(a == AcceptAllNamespaceFilter.INSTANCE || b == AcceptAllNamespaceFilter.INSTANCE)
  28             return AcceptAllNamespaceFilter.INSTANCE;
  29         if(a instanceof PositiveNamespaceFilter) {
  30             if(b instanceof PositiveNamespaceFilter)
  31                 return unionImpl((PositiveNamespaceFilter)a, (PositiveNamespaceFilter)b);
  32             else if(b instanceof NegativeNamespaceFilter)
  33                 return unionImpl((NegativeNamespaceFilter)b, (PositiveNamespaceFilter)a);
  34         }
  35         else if(a instanceof NegativeNamespaceFilter) {
  36             if(b instanceof PositiveNamespaceFilter)
  37                 return unionImpl((NegativeNamespaceFilter)a, (PositiveNamespaceFilter)b);
  38             else if(b instanceof NegativeNamespaceFilter)
  39                 return unionImpl((NegativeNamespaceFilter)a, (NegativeNamespaceFilter)b);
  40         }
  41         return new NamespaceFilterUnion(a, b);
  42     }
  43
  44     private static NamespaceFilter unionImpl(PositiveNamespaceFilter a, PositiveNamespaceFilter b) {
  45         THashSet<String> includedValues = new THashSet<String>(a.includedValues.size() + b.includedValues.size());
  46         includedValues.addAll(a.includedValues);
  47         includedValues.addAll(b.includedValues);
  48         if(includedValues.size() == a.includedValues.size())
  49             return a;
  50         if(includedValues.size() == b.includedValues.size())
  51             return b;
  52         return new PositiveNamespaceFilter(includedValues);
  53     }
  54
  55     private static NamespaceFilter unionImpl(NegativeNamespaceFilter a, PositiveNamespaceFilter b) {
  56         THashSet<String> excludedValues = new THashSet<String>(a.excludedValues);
  57         excludedValues.removeAll(b.includedValues);
  58         if(excludedValues.size() == a.excludedValues.size())
  59             return a;
  60         if(excludedValues.isEmpty())
  61             return AcceptAllNamespaceFilter.INSTANCE;
  62         return new NegativeNamespaceFilter(excludedValues);
  63     }
  64
  65     private static NamespaceFilter unionImpl(NegativeNamespaceFilter a, NegativeNamespaceFilter b) {
  66         THashSet<String> excludedValues = new THashSet<String>(a.excludedValues);
  67         excludedValues.retainAll(b.excludedValues);
  68         if(excludedValues.size() == a.excludedValues.size())
  69             return a;
  70         if(excludedValues.size() == b.excludedValues.size())
  71             return b;
  72         if(excludedValues.isEmpty())
  73             return AcceptAllNamespaceFilter.INSTANCE;
  74         return new NegativeNamespaceFilter(excludedValues);
  75     }
  76
  77     public static NamespaceFilter intersection(NamespaceFilter a, NamespaceFilter b) {
  78         if(a == AcceptAllNamespaceFilter.INSTANCE)
  79             return b;
  80         if(b == AcceptAllNamespaceFilter.INSTANCE)
  81             return a;
  82         if(a instanceof PositiveNamespaceFilter) {
  83             if(b instanceof PositiveNamespaceFilter)
  84                 return intersectionImpl((PositiveNamespaceFilter)a, (PositiveNamespaceFilter)b);
  85             else if(b instanceof NegativeNamespaceFilter)
  86                 return intersectionImpl((PositiveNamespaceFilter)a, (NegativeNamespaceFilter)b);
  87         }
  88         else if(a instanceof NegativeNamespaceFilter) {
  89             if(b instanceof PositiveNamespaceFilter)
  90                 return intersectionImpl((PositiveNamespaceFilter)b, (NegativeNamespaceFilter)a);
  91             else if(b instanceof NegativeNamespaceFilter)
  92                 return intersectionImpl((NegativeNamespaceFilter)a, (NegativeNamespaceFilter)b);
  93         }
  94         return new NamespaceFilterIntersection(a, b);
  95     }
  96
  97     private static NamespaceFilter intersectionImpl(NegativeNamespaceFilter a,
  98             NegativeNamespaceFilter b) {
  99         THashSet<String> excludedValues = new THashSet<String>(a.excludedValues.size() + b.excludedValues.size());
 100         excludedValues.addAll(a.excludedValues);
 101         excludedValues.addAll(b.excludedValues);
 102         if(excludedValues.size() == a.excludedValues.size())
 103             return a;
 104         if(excludedValues.size() == b.excludedValues.size())
 105             return b;
 106         return new NegativeNamespaceFilter(excludedValues);
 107     }
 108
 109     private static NamespaceFilter intersectionImpl(PositiveNamespaceFilter a,
 110             NegativeNamespaceFilter b) {
 111         THashSet<String> includedValues = new THashSet<String>(a.includedValues);
 112         includedValues.removeAll(b.excludedValues);
 113         if(includedValues.size() == a.includedValues.size())
 114             return a;
 115         return new PositiveNamespaceFilter(includedValues);
 116     }
 117
 118     private static NamespaceFilter intersectionImpl(PositiveNamespaceFilter a,
 119             PositiveNamespaceFilter b) {
 120         THashSet<String> includedValues = new THashSet<String>(a.includedValues);
 121         includedValues.retainAll(b.includedValues);
 122         if(includedValues.size() == a.includedValues.size())
 123             return a;
 124         if(includedValues.size() == b.includedValues.size())
 125             return b;
 126         return new PositiveNamespaceFilter(includedValues);
 127     }
 128 }