Axiom: Added special handling for AxiomTypeReference

Signed-off-by: Tony Tkacik <tonydamage@gmail.com>
Evolveum · May 13, 2020 · 4c0f8bd · 4c0f8bd
1 parent 4de9cd2
commit 4c0f8bd
Show file tree

Hide file tree

Showing 18 changed files with 580 additions and 267 deletions.
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java
@@ -33,7 +33,7 @@ public static class Item implements AxiomItemDefinition {
         public static final AxiomItemDefinition VERSION = new Item("version", Type.STRING, true);
         public static final AxiomItemDefinition TYPE_REFERENCE = new Item("type", Type.TYPE_REFERENCE, true);
         public static final AxiomItemDefinition TYPE_DEFINITION = new Item("type", Type.TYPE_DEFINITION, false);
-        public static final AxiomItemDefinition SUPERTYPE_REFERENCE = new Item("extends", Type.IDENTIFIER, false);
+        public static final AxiomItemDefinition SUPERTYPE_REFERENCE = new Item("extends", Type.TYPE_REFERENCE, false);
         public static final AxiomItemDefinition ROOT_DEFINITION = new Item("root", Type.ITEM_DEFINITION, false);
         public static final AxiomItemDefinition OBJECT_DEFINITION = new Item("object", Type.OBJECT_DEFINITION, false);
         public static final AxiomItemDefinition REFERENCE_DEFINITION = new Item("reference", Type.ITEM_DEFINITION, false);

diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomSchemaContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomSchemaContext.java
@@ -9,6 +9,8 @@ public interface AxiomSchemaContext {
 
     Collection<AxiomItemDefinition> roots();
 
+    Optional<AxiomItemDefinition> getRoot(AxiomIdentifier type);
+
     Optional<AxiomTypeDefinition> getType(AxiomIdentifier type);
 
     Collection<AxiomTypeDefinition> types();

diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java
@@ -0,0 +1,58 @@
+package com.evolveum.axiom.lang.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+
+import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.lang.api.AxiomBuiltIn;
+import com.evolveum.axiom.lang.api.AxiomItemDefinition;
+import com.evolveum.axiom.lang.api.AxiomSchemaContext;
+import com.evolveum.axiom.lang.api.AxiomTypeDefinition;
+import com.google.common.collect.ImmutableMap;
+
+public class AxiomSchemaContextImpl implements AxiomSchemaContext {
+
+    private Map<AxiomIdentifier, AxiomItemDefinition> roots;
+    private Map<AxiomIdentifier, AxiomTypeDefinition> types;
+
+    public AxiomSchemaContextImpl(Map<AxiomIdentifier, AxiomItemDefinition> roots,
+            Map<AxiomIdentifier, AxiomTypeDefinition> types) {
+        this.roots = roots;
+        this.types = types;
+    }
+
+    public static AxiomSchemaContext of(Map<AxiomIdentifier, AxiomItemDefinition> roots,
+            Map<AxiomIdentifier, AxiomTypeDefinition> types) {
+        return new AxiomSchemaContextImpl(roots, types);
+    }
+
+    @Override
+    public Collection<AxiomItemDefinition> roots() {
+        return roots.values();
+    }
+
+    @Override
+    public Optional<AxiomTypeDefinition> getType(AxiomIdentifier type) {
+        return Optional.ofNullable(types.get(type));
+    }
+
+    @Override
+    public Collection<AxiomTypeDefinition> types() {
+        return types.values();
+    }
+
+    @Override
+    public Optional<AxiomItemDefinition> getRoot(AxiomIdentifier type) {
+        return Optional.ofNullable(roots.get(type));
+    }
+
+    public static AxiomSchemaContextImpl boostrapContext() {
+        return new AxiomSchemaContextImpl(ImmutableMap.of(AxiomBuiltIn.Item.MODEL_DEFINITION.name(), AxiomBuiltIn.Item.MODEL_DEFINITION),
+                ImmutableMap.of());
+    }
+
+    public static AxiomSchemaContext baseLanguageContext() {
+        return ModelReactorContext.BASE_LANGUAGE.get();
+    }
+}
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomTypeDefinitionImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomTypeDefinitionImpl.java
@@ -22,23 +22,31 @@ public class AxiomTypeDefinitionImpl extends AbstractAxiomBaseDefinition impleme
 
     public static final Factory<AxiomIdentifier, AxiomTypeDefinitionImpl> FACTORY =AxiomTypeDefinitionImpl::new;
     private final Map<AxiomIdentifier, AxiomItemDefinition> items;
+    private final Optional<AxiomTypeDefinition> superType;
+    private Optional<AxiomItemDefinition> argument;
 
     public AxiomTypeDefinitionImpl(AxiomIdentifier keyword, AxiomIdentifier value, List<AxiomStatement<?>> children,
             Multimap<AxiomIdentifier, AxiomStatement<?>> keywordMap) {
         super(keyword, value, children, keywordMap);
         ImmutableMap.Builder<AxiomIdentifier, AxiomItemDefinition> builder =  ImmutableMap.builder();
         putAll(builder, children(ITEM_DEFINITION.name(), AxiomItemDefinition.class));
         items = builder.build();
+        superType = first(SUPERTYPE_REFERENCE.name(), AxiomTypeDefinition.class);
+        argument = firstValue(ARGUMENT.name(), AxiomIdentifier.class)
+                .flatMap((AxiomIdentifier k) -> item(k));
     }
 
     @Override
     public Optional<AxiomItemDefinition> argument() {
-        return first(ARGUMENT.name(), AxiomItemDefinition.class);
+        if(argument.isEmpty() && superType().isPresent()) {
+            return superType().get().argument();
+        }
+        return argument;
     }
 
     @Override
     public Optional<AxiomTypeDefinition> superType() {
-        return first(SUPERTYPE_REFERENCE.name(), AxiomTypeDefinition.class);
+        return superType;
     }
 
     @Override

diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java
@@ -5,15 +5,13 @@
 import java.util.function.Supplier;
 
 import com.evolveum.axiom.api.AxiomIdentifier;
-import com.evolveum.axiom.lang.api.AxiomBuiltIn;
 import com.evolveum.axiom.lang.api.AxiomBuiltIn.Item;
 import com.evolveum.axiom.lang.api.AxiomBuiltIn.Type;
 import com.evolveum.axiom.lang.api.AxiomItemDefinition;
 import com.evolveum.axiom.lang.api.AxiomTypeDefinition;
 import com.evolveum.axiom.lang.api.stmt.AxiomStatement;
 import com.google.common.collect.ImmutableSet;
 
-import static com.evolveum.axiom.lang.api.AxiomBuiltIn.*;
 
 public enum BasicStatementRule implements StatementRule<AxiomIdentifier> {
 
@@ -36,27 +34,27 @@ public void apply(StatementRuleContext<AxiomIdentifier> rule) throws AxiomSemant
         }
     },
 
-    ADD_TYPE_TO_ITEM(items(Item.TYPE_REFERENCE), types(Type.TYPE_REFERENCE)) {
+    EXPAND_TYPE_REFERENCE(all(), types(Type.TYPE_REFERENCE)) {
         @Override
         public void apply(StatementRuleContext<AxiomIdentifier> rule) throws AxiomSemanticException {
             AxiomIdentifier type = rule.requireValue();
-            Requirement<Supplier<AxiomStatement<?>>> typeDef = rule.requireGlobalItem(Item.TYPE_DEFINITION, type);
+            Requirement<AxiomStatement<?>> typeDef = rule.requireGlobalItem(Item.TYPE_DEFINITION, type);
             rule.apply(ctx -> {
-                ctx.parent().builder().add(Item.TYPE_DEFINITION, typeDef.get());
+                ctx.replace(typeDef);
             });
             rule.errorMessage(() ->  rule.error("type '%s' was not found.", type));
         }
-    },
-
+    };
+/*
     ADD_SUPERTYPE(items(), types(Type.TYPE_DEFINITION)) {
 
         @Override
         public void apply(StatementRuleContext<AxiomIdentifier> rule) throws AxiomSemanticException {
             Optional<AxiomIdentifier> superType = rule.optionalChildValue(Item.SUPERTYPE_REFERENCE, AxiomIdentifier.class);
             if(superType.isPresent()) {
-                Requirement<Supplier<AxiomStatement<?>>> req = rule.requireGlobalItem(Item.TYPE_DEFINITION, superType.get());
+                Requirement<AxiomStatement<?>> req = rule.requireGlobalItem(Item.TYPE_DEFINITION, superType.get());
                 rule.apply((ctx) -> {
-                    ctx.builder().add(Item.SUPERTYPE_REFERENCE, req.get());
+                    //ctx.builder().add(Item.SUPERTYPE_REFERENCE, req.get());
                 });
                 rule.errorMessage(() -> {
                     if(!req.isSatisfied()) {
@@ -66,7 +64,7 @@ public void apply(StatementRuleContext<AxiomIdentifier> rule) throws AxiomSemant
                 });
             }
         }
-    };
+    };*/
 
     private final Set<AxiomIdentifier> items;
     private final Set<AxiomIdentifier> types;

diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/Deffered.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/Deffered.java
@@ -0,0 +1,40 @@
+package com.evolveum.axiom.lang.impl;
+
+import java.util.Optional;
+
+import com.google.common.base.Preconditions;
+
+class Deffered<T> extends Requirement.Delegated<T> {
+
+    private Object ret;
+
+    Deffered(Requirement<T> delegate) {
+        ret = delegate;
+    }
+
+    @Override
+    Requirement<T> delegate() {
+        if(ret instanceof Requirement<?>) {
+            return (Requirement<T>) ret;
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isSatisfied() {
+        if(delegate() != null) {
+            if(delegate().isSatisfied()) {
+                ret = delegate().get();
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public T get() {
+        Preconditions.checkState(isSatisfied(), "Requirement was not satisfied");
+        return (T) ret;
+    }
+}
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/DelegatedRequirement.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/DelegatedRequirement.java
@@ -0,0 +1,7 @@
+package com.evolveum.axiom.lang.impl;
+
+import java.util.Optional;
+
+import com.google.common.base.Preconditions;
+
+