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