bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/environment/NamespaceImpl.java

   1 package org.simantics.scl.compiler.environment;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.function.Consumer;
   6
   7 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
   8 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
   9 import org.simantics.scl.compiler.elaboration.modules.TypeClass;
  10 import org.simantics.scl.compiler.elaboration.modules.TypeDescriptor;
  11 import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
  12 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  13 import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
  14 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  15 import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
  16 import org.simantics.scl.compiler.environment.filter.NamespaceFilters;
  17 import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
  18 import org.simantics.scl.compiler.module.Module;
  19 import org.simantics.scl.compiler.types.TCon;
  20
  21 import gnu.trove.map.hash.THashMap;
  22 import gnu.trove.procedure.TObjectProcedure;
  23
  24 public class NamespaceImpl implements Namespace {
  25
  26     private final THashMap<String, Namespace> namespaceMap;
  27     private final ModuleImport[] moduleImports;
  28
  29     public static class ModuleImport {
  30         public final Module module;
  31         public NamespaceFilter filter;
  32
  33         public ModuleImport(Module module, NamespaceFilter filter) {
  34             this.module = module;
  35             this.filter = filter;
  36         }
  37     }
  38
  39     public NamespaceImpl(THashMap<String, Namespace> namespaceMap,
  40             ModuleImport[] moduleImports) {
  41         this.namespaceMap = namespaceMap;
  42         this.moduleImports = moduleImports;
  43     }
  44
  45     @Override
  46     public Namespace getNamespace(String name) {
  47         return namespaceMap.get(name);
  48     }
  49
  50     @Override
  51     public Collection<String> getNamespaces() {
  52         return namespaceMap.keySet();
  53     }
  54
  55     @Override
  56     public SCLValue getValue(String name) throws AmbiguousNameException {
  57         SCLValue result = null, temp;
  58         Module resultModule = null;
  59         ArrayList<String> conflictingModules = null;
  60         for(ModuleImport moduleImport : moduleImports) {
  61             Module module = moduleImport.module;
  62             temp = module.getValue(name);
  63             if(temp != null
  64                     && !temp.isPrivate()
  65                     && moduleImport.filter.isValueIncluded(name)) {
  66                 if(result != null) {
  67                     if(conflictingModules == null) {
  68                         conflictingModules = new ArrayList<String>(2);
  69                         conflictingModules.add(resultModule.getName());
  70                     }
  71                     conflictingModules.add(module.getName());
  72                 }
  73                 else {
  74                     result = temp;
  75                     resultModule = module;
  76                 }
  77             }
  78         }
  79         if(conflictingModules != null)
  80             throw new AmbiguousNameException(conflictingModules, name);
  81         return result;
  82     }
  83
  84     @Override
  85     public SCLRelation getRelation(String name) throws AmbiguousNameException {
  86         SCLRelation result = null, temp;
  87         Module resultModule = null;
  88         ArrayList<String> conflictingModules = null;
  89         for(ModuleImport moduleImport : moduleImports) {
  90             Module module = moduleImport.module;
  91             temp = module.getRelation(name);
  92             if(temp != null) {
  93                 if(result != null) {
  94                     if(conflictingModules == null) {
  95                         conflictingModules = new ArrayList<String>(2);
  96                         conflictingModules.add(resultModule.getName());
  97                     }
  98                     conflictingModules.add(module.getName());
  99                 }
 100                 else {
 101                     result = temp;
 102                     resultModule = module;
 103                 }
 104             }
 105         }
 106         if(conflictingModules != null)
 107             throw new AmbiguousNameException(conflictingModules, name);
 108         return result;
 109     }
 110
 111     @Override
 112     public SCLEntityType getEntityType(String name)
 113             throws AmbiguousNameException {
 114         SCLEntityType result = null, temp;
 115         Module resultModule = null;
 116         ArrayList<String> conflictingModules = null;
 117         for(ModuleImport moduleImport : moduleImports) {
 118             Module module = moduleImport.module;
 119             temp = module.getEntityType(name);
 120             if(temp != null) {
 121                 if(result != null) {
 122                     if(conflictingModules == null) {
 123                         conflictingModules = new ArrayList<String>(2);
 124                         conflictingModules.add(resultModule.getName());
 125                     }
 126                     conflictingModules.add(module.getName());
 127                 }
 128                 else {
 129                     result = temp;
 130                     resultModule = module;
 131                 }
 132             }
 133         }
 134         if(conflictingModules != null)
 135             throw new AmbiguousNameException(conflictingModules, name);
 136         return result;
 137     }
 138
 139     @Override
 140     public TypeDescriptor getTypeDescriptor(String name)
 141             throws AmbiguousNameException {
 142         TypeDescriptor result = null, temp;
 143         Module resultModule = null;
 144         ArrayList<String> conflictingModules = null;
 145         for(ModuleImport moduleImport : moduleImports) {
 146             Module module = moduleImport.module;
 147             temp = module.getTypeDescriptor(name);
 148             if(temp != null) {
 149                 if(result != null) {
 150                     if(conflictingModules == null) {
 151                         conflictingModules = new ArrayList<String>(2);
 152                         conflictingModules.add(resultModule.getName());
 153                     }
 154                     conflictingModules.add(module.getName());
 155                 }
 156                 else {
 157                     result = temp;
 158                     resultModule = module;
 159                 }
 160             }
 161         }
 162         if(conflictingModules != null)
 163             throw new AmbiguousNameException(conflictingModules, name);
 164         return result;
 165     }
 166
 167     @Override
 168     public EffectConstructor getEffectConstructor(String name)
 169             throws AmbiguousNameException {
 170         EffectConstructor result = null, temp;
 171         Module resultModule = null;
 172         ArrayList<String> conflictingModules = null;
 173         for(ModuleImport moduleImport : moduleImports) {
 174             Module module = moduleImport.module;
 175             temp = module.getEffectConstructor(name);
 176             if(temp != null) {
 177                 if(result != null) {
 178                     if(conflictingModules == null) {
 179                         conflictingModules = new ArrayList<String>(2);
 180                         conflictingModules.add(resultModule.getName());
 181                     }
 182                     conflictingModules.add(module.getName());
 183                 }
 184                 else {
 185                     result = temp;
 186                     resultModule = module;
 187                 }
 188             }
 189         }
 190         if(conflictingModules != null)
 191             throw new AmbiguousNameException(conflictingModules, name);
 192         return result;
 193     }
 194
 195     @Override
 196     public TypeClass getTypeClass(String name) throws AmbiguousNameException {
 197         TypeClass result = null, temp;
 198         Module resultModule = null;
 199         ArrayList<String> conflictingModules = null;
 200         for(ModuleImport moduleImport : moduleImports) {
 201             Module module = moduleImport.module;
 202             temp = module.getTypeClass(name);
 203             if(temp != null) {
 204                 if(result != null) {
 205                     if(conflictingModules == null) {
 206                         conflictingModules = new ArrayList<String>(2);
 207                         conflictingModules.add(resultModule.getName());
 208                     }
 209                     conflictingModules.add(module.getName());
 210                 }
 211                 else {
 212                     result = temp;
 213                     resultModule = module;
 214                 }
 215             }
 216         }
 217         if(conflictingModules != null)
 218             throw new AmbiguousNameException(conflictingModules, name);
 219         return result;
 220     }
 221
 222     @Override
 223     public MappingRelation getMappingRelation(String name) throws AmbiguousNameException {
 224         MappingRelation result = null, temp;
 225         Module resultModule = null;
 226         ArrayList<String> conflictingModules = null;
 227         for(ModuleImport moduleImport : moduleImports) {
 228             Module module = moduleImport.module;
 229             temp = module.getMappingRelation(name);
 230             if(temp != null) {
 231                 if(result != null) {
 232                     if(conflictingModules == null) {
 233                         conflictingModules = new ArrayList<String>(2);
 234                         conflictingModules.add(resultModule.getName());
 235                     }
 236                     conflictingModules.add(module.getName());
 237                 }
 238                 else {
 239                     result = temp;
 240                     resultModule = module;
 241                 }
 242             }
 243         }
 244         if(conflictingModules != null)
 245             throw new AmbiguousNameException(conflictingModules, name);
 246         return result;
 247     }
 248
 249     @Override
 250     public TransformationRule getRule(String name) throws AmbiguousNameException {
 251         TransformationRule result = null, temp;
 252         Module resultModule = null;
 253         ArrayList<String> conflictingModules = null;
 254         for(ModuleImport moduleImport : moduleImports) {
 255             Module module = moduleImport.module;
 256             temp = module.getRule(name);
 257             if(temp != null) {
 258                 if(result != null) {
 259                     if(conflictingModules == null) {
 260                         conflictingModules = new ArrayList<String>(2);
 261                         conflictingModules.add(resultModule.getName());
 262                     }
 263                     conflictingModules.add(module.getName());
 264                 }
 265                 else {
 266                     result = temp;
 267                     resultModule = module;
 268                 }
 269             }
 270         }
 271         if(conflictingModules != null)
 272             throw new AmbiguousNameException(conflictingModules, name);
 273         return result;
 274     }
 275
 276     @Override
 277     public CHRRuleset getRuleset(String name) throws AmbiguousNameException {
 278         CHRRuleset result = null, temp;
 279         Module resultModule = null;
 280         ArrayList<String> conflictingModules = null;
 281         for(ModuleImport moduleImport : moduleImports) {
 282             Module module = moduleImport.module;
 283             temp = module.getRuleset(name);
 284             if(temp != null) {
 285                 if(result != null) {
 286                     if(conflictingModules == null) {
 287                         conflictingModules = new ArrayList<String>(2);
 288                         conflictingModules.add(resultModule.getName());
 289                     }
 290                     conflictingModules.add(module.getName());
 291                 }
 292                 else {
 293                     result = temp;
 294                     resultModule = module;
 295                 }
 296             }
 297         }
 298         if(conflictingModules != null)
 299             throw new AmbiguousNameException(conflictingModules, name);
 300         return result;
 301     }
 302
 303     @Override
 304     public void findValuesForPrefix(String prefix, NamespaceFilter filter, TObjectProcedure<SCLValue> proc) {
 305         for(ModuleImport moduleImport : moduleImports)
 306             moduleImport.module.findValuesForPrefix(prefix,
 307                     NamespaceFilters.intersection(filter, moduleImport.filter),
 308                     proc);
 309     }
 310
 311     @Override
 312     public void findTypesForPrefix(String prefix, NamespaceFilter filter, Consumer<TCon> consumer) {
 313         for(ModuleImport moduleImport : moduleImports)
 314             moduleImport.module.findTypesForPrefix(prefix,
 315                     NamespaceFilters.intersection(filter, moduleImport.filter),
 316                     consumer);
 317     }
 318
 319 }