bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/ConcreteModule.java

   1 package org.simantics.scl.compiler.module;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.Collections;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.function.Consumer;
   9
  10 import org.simantics.scl.compiler.common.names.Name;
  11 import org.simantics.scl.compiler.constants.Constant;
  12 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
  13 import org.simantics.scl.compiler.elaboration.modules.Documentation;
  14 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
  15 import org.simantics.scl.compiler.elaboration.modules.TypeClass;
  16 import org.simantics.scl.compiler.elaboration.modules.TypeClassInstance;
  17 import org.simantics.scl.compiler.elaboration.modules.TypeDescriptor;
  18 import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
  19 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  20 import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
  21 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  22 import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
  23 import org.simantics.scl.compiler.errors.CompilationError;
  24 import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
  25 import org.simantics.scl.compiler.top.ModuleInitializer;
  26 import org.simantics.scl.compiler.types.TCon;
  27 import org.simantics.scl.runtime.profiling.BranchPoint;
  28
  29 import gnu.trove.map.hash.THashMap;
  30 import gnu.trove.procedure.TObjectObjectProcedure;
  31 import gnu.trove.procedure.TObjectProcedure;
  32
  33 public class ConcreteModule implements Module {
  34     String moduleName;
  35     String defaultLocalName;
  36     String deprecation;
  37     THashMap<String, TypeDescriptor> typeDescriptors = new THashMap<String, TypeDescriptor>();
  38     THashMap<String, EffectConstructor> effectConstructors = new THashMap<String, EffectConstructor>();
  39     THashMap<String, TypeClass> typeClasses = new THashMap<String, TypeClass>();
  40     THashMap<TCon, ArrayList<TypeClassInstance>> typeClassInstances = new THashMap<TCon, ArrayList<TypeClassInstance>>();
  41     THashMap<String, SCLValue> values = new THashMap<String, SCLValue>();
  42     THashMap<String, List<Constant>> fieldAccessors = new THashMap<String, List<Constant>>();
  43     THashMap<String, SCLRelation> relations = new THashMap<String, SCLRelation>(2);
  44     THashMap<String, SCLEntityType> entityTypes = new THashMap<String, SCLEntityType>(2);
  45     THashMap<String, TransformationRule> rules = new THashMap<String, TransformationRule>(2);
  46     THashMap<String, MappingRelation> mappingRelations = new THashMap<String, MappingRelation>(2);
  47     THashMap<String, CHRRuleset> rulesets = new THashMap<String, CHRRuleset>(2);
  48     ArrayList<ImportDeclaration> dependencies = new ArrayList<ImportDeclaration>();
  49     THashMap<String, BranchPoint[]> branchPoints;
  50     CompilationError[] warnings = CompilationError.EMPTY_ARRAY;
  51
  52     Map<String, byte[]> classes = Collections.emptyMap();
  53     ClassLoader parentClassLoader;
  54     ModuleInitializer moduleInitializer;
  55
  56     protected Documentation documentation;
  57
  58     public ConcreteModule(String moduleName) {
  59         this.moduleName = moduleName;
  60     }
  61
  62     @Override
  63     public String getDefaultLocalName() {
  64         return defaultLocalName;
  65     }
  66
  67     public void setDefaultLocalName(String defaultLocalName) {
  68                 this.defaultLocalName = defaultLocalName;
  69         }
  70
  71     public boolean addTypeDescriptor(String name, TypeDescriptor typeConstructor) {
  72         return typeDescriptors.put(name, typeConstructor) != null;
  73     }
  74
  75     public boolean addEffectConstructor(String name, EffectConstructor effectConstructor) {
  76         return effectConstructors.put(name, effectConstructor) != null;
  77     }
  78
  79     public boolean addTypeClass(String name, TypeClass typeClass) {
  80         return typeClasses.put(name, typeClass) != null;
  81     }
  82
  83     public void addTypeClassInstance(TCon typeClass, TypeClassInstance typeClassInstance) {
  84         ArrayList<TypeClassInstance> instances = typeClassInstances.get(typeClass);
  85         if(instances == null) {
  86             instances = new ArrayList<TypeClassInstance>();
  87             typeClassInstances.put(typeClass, instances);
  88         }
  89         instances.add(typeClassInstance);
  90     }
  91
  92     public boolean addRule(TransformationRule rule) {
  93         return rules.put(rule.name.name, rule) != null;
  94     }
  95
  96     public boolean addMappingRelation(MappingRelation relation) {
  97         return mappingRelations.put(relation.name.name, relation) != null;
  98     }
  99
 100     public Collection<TCon> getTypeClassesWithInstances() {
 101         return typeClassInstances.keySet();
 102     }
 103
 104     public boolean addValue(SCLValue value) {
 105         return values.put(value.getName().name, value) != null;
 106     }
 107
 108     public SCLValue addValue(String name, Constant constant) {
 109         SCLValue value = new SCLValue(Name.create(moduleName, name), constant);
 110         addValue(value);
 111         return value;
 112     }
 113
 114     @Override
 115     public List<Constant> getFieldAccessors(String name) {
 116         return fieldAccessors.get(name);
 117     }
 118
 119     public void addRelation(String name, SCLRelation relation) {
 120         relations.put(name, relation);
 121     }
 122
 123     public void addEntityType(String name, SCLEntityType entityType) {
 124         entityTypes.put(name, entityType);
 125     }
 126
 127     public void addDependency(ImportDeclaration module) {
 128         if(!dependencies.contains(module))
 129             dependencies.add(module);
 130     }
 131
 132     public Collection<SCLValue> getValues() {
 133         return values.values();
 134     }
 135
 136     public Collection<TransformationRule> getRules() {
 137         return rules.values();
 138     }
 139
 140     public Collection<MappingRelation> getMappingRelations() {
 141         return mappingRelations.values();
 142     }
 143
 144     @Override
 145     public String getName() {
 146         return moduleName;
 147     }
 148
 149     @Override
 150     public SCLValue getValue(String name) {
 151         return values.get(name);
 152     }
 153
 154     @Override
 155     public SCLRelation getRelation(String name) {
 156         return relations.get(name);
 157     }
 158
 159     @Override
 160     public MappingRelation getMappingRelation(String name) {
 161         return mappingRelations.get(name);
 162     }
 163
 164     @Override
 165     public TransformationRule getRule(String name) {
 166         return rules.get(name);
 167     }
 168
 169     @Override
 170     public SCLEntityType getEntityType(String name) {
 171         return entityTypes.get(name);
 172     }
 173
 174     public TypeClass getTypeClass(String name) {
 175         return typeClasses.get(name);
 176     }
 177
 178     @Override
 179     public Collection<TypeClassInstance> getInstances(TCon typeClass) {
 180         Collection<TypeClassInstance> result = typeClassInstances.get(typeClass);
 181         if(result == null)
 182             return Collections.emptyList();
 183         else
 184             return result;
 185     }
 186
 187     @Override
 188     public TypeDescriptor getTypeDescriptor(String name) {
 189         return typeDescriptors.get(name);
 190     }
 191
 192     @Override
 193     public EffectConstructor getEffectConstructor(String name) {
 194         return effectConstructors.get(name);
 195     }
 196
 197     @Override
 198     public CHRRuleset getRuleset(String name) {
 199         return rulesets.get(name);
 200     }
 201
 202     public Collection<TypeClass> getTypeClasses() {
 203         return typeClasses.values();
 204     }
 205
 206     public THashMap<TCon, ArrayList<TypeClassInstance>> getTypeInstances() {
 207         return typeClassInstances;
 208     }
 209
 210     @Override
 211     public List<ImportDeclaration> getDependencies() {
 212         return dependencies;
 213     }
 214
 215     public void setDocumentation(Documentation documentation) {
 216         this.documentation = documentation;
 217     }
 218
 219     public Documentation getDocumentation() {
 220         return documentation;
 221     }
 222
 223     public void setClasses(Map<String, byte[]> classes) {
 224         this.classes = classes;
 225     }
 226
 227     @Override
 228     public byte[] getClass(String name) {
 229         return classes.get(name);
 230     }
 231
 232     public void setModuleInitializer(ModuleInitializer moduleInitializer) {
 233         this.moduleInitializer = moduleInitializer;
 234     }
 235
 236     @Override
 237     public ModuleInitializer getModuleInitializer() {
 238         return moduleInitializer;
 239     }
 240
 241     @Override
 242     public String toString() {
 243         return moduleName;
 244     }
 245
 246     @Override
 247     public void findValuesForPrefix(final String prefix, final NamespaceFilter filter,
 248             final TObjectProcedure<SCLValue> proc) {
 249         this.values.forEachEntry(new TObjectObjectProcedure<String,SCLValue>() {
 250             @Override
 251             public boolean execute(String name, SCLValue value) {
 252                 if(value.isPrivate())
 253                     return true;
 254                 String lowerPrefix = prefix.toLowerCase();
 255                 String lowerName = name.toLowerCase();
 256                 if(lowerName.startsWith(lowerPrefix) && filter.isValueIncluded(name))
 257                     proc.execute(value);
 258                 return true;
 259             }
 260         });
 261     }
 262
 263     @Override
 264     public void findValuesForPrefix(String prefix, NamespaceFilter filter, Consumer<SCLValue> consumer) {
 265         values.values().forEach((Consumer<SCLValue>) (value) -> {
 266             String lowerPrefix = prefix.toLowerCase();
 267             String lowerName = value.getName().name.toLowerCase();
 268             if(lowerName.startsWith(lowerPrefix) && filter.isValueIncluded(value.getName().name))
 269                 consumer.accept(value);
 270         });
 271     }
 272
 273     public Collection<SCLRelation> getRelations() {
 274         return relations.values();
 275     }
 276
 277     @Override
 278     public void findTypesForPrefix(String prefix, NamespaceFilter filter, Consumer<TCon> consumer) {
 279         typeDescriptors.values().forEach(type -> {
 280             TCon tcon = type.name;
 281             if (tcon.name.toLowerCase().startsWith(prefix.toLowerCase()) && filter.isValueIncluded(tcon.name))
 282                 consumer.accept(tcon);
 283         });
 284     }
 285
 286     public void setBranchPoints(THashMap<String, BranchPoint[]> branchPoints) {
 287         this.branchPoints = branchPoints;
 288     }
 289
 290     @Override
 291     public THashMap<String, BranchPoint[]> getBranchPoints() {
 292         return branchPoints;
 293     }
 294
 295     @Override
 296     public void dispose() {
 297     }
 298
 299     public void setWarnings(CompilationError[] warnings) {
 300         this.warnings = warnings;
 301     }
 302
 303     public CompilationError[] getWarnings() {
 304         return warnings;
 305     }
 306
 307     @Override
 308     public ClassLoader getParentClassLoader() {
 309         return parentClassLoader;
 310     }
 311
 312     public void setParentClassLoader(ClassLoader parentClassLoader) {
 313         if(parentClassLoader == null)
 314             throw new NullPointerException();
 315         this.parentClassLoader = parentClassLoader;
 316     }
 317
 318     public void addFieldAccessor(String name, Constant accessor) {
 319         List<Constant> list = fieldAccessors.get(name);
 320         if(list == null) {
 321             list = new ArrayList<Constant>(2);
 322             fieldAccessors.put(name, list);
 323         }
 324         list.add(accessor);
 325     }
 326
 327     public void addRuleset(String name, CHRRuleset ruleset) {
 328         rulesets.put(name, ruleset);
 329     }
 330
 331     @Override
 332     public String getDeprecation() {
 333         return deprecation;
 334     }
 335
 336     public void setDeprecation(String deprecation) {
 337         this.deprecation = deprecation;
 338     }
 339 }