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