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