Add script data type implementations

Author: zhossain-info

src/main/java/com/relogiclabs/jschema/internal/script/GArray.java

@@ -0,0 +1,65 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.exception.ScriptCommonException;
+import com.relogiclabs.jschema.type.EArray;
+import com.relogiclabs.jschema.type.EValue;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static com.relogiclabs.jschema.internal.util.StringHelper.concat;
+import static com.relogiclabs.jschema.internal.util.StringHelper.joinWith;
+import static com.relogiclabs.jschema.message.ErrorCode.INDX01;
+
+@Getter
+@EqualsAndHashCode
+public final class GArray implements EArray {
+    private static final int MAX_LIMIT = Short.MAX_VALUE;
+    private final List<EValue> elements;
+
+    private GArray(int size) {
+        this.elements = new ArrayList<>(size);
+    }
+
+    public GArray(Collection<? extends EValue> collection) {
+        this.elements = new ArrayList<>(collection.size());
+        for(var v : collection) elements.add(new GReference(v));
+    }
+
+    public static GArray filledFrom(EValue value, int size) {
+        var array = new GArray(size);
+        for(int i = 0; i < size; i++) array.elements.add(new GReference(value));
+        return array;
+    }
+
+    public static GArray from(EArray array, GRange range) {
+        var list = array.elements();
+        var size = list.size();
+        return new GArray(list.subList(range.getStart(size), range.getEnd(size)));
+    }
+
+    @Override
+    public EValue get(int index) {
+        var size = elements.size();
+        if(index < size) return elements.get(index);
+        if(index > MAX_LIMIT) throw new ScriptCommonException(INDX01,
+                concat("Array index ", index, " exceeds maximum size limit"));
+        if(index > size) throw new ArrayIndexOutOfBoundsException(index);
+        var element = new GReference(VOID);
+        elements.add(element);
+        return element;
+    }
+
+    @Override
+    public List<? extends EValue> elements() {
+        return elements;
+    }
+
+    @Override
+    public String toString() {
+        return joinWith(elements, ", ", "[", "]");
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GBoolean.java

@@ -0,0 +1,25 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.type.EBoolean;
+import lombok.EqualsAndHashCode;
+import lombok.RequiredArgsConstructor;
+
+import static lombok.AccessLevel.PRIVATE;
+
+@EqualsAndHashCode
+@RequiredArgsConstructor(access = PRIVATE)
+public final class GBoolean implements EBoolean {
+    public static final GBoolean TRUE = new GBoolean(true);
+    public static final GBoolean FALSE = new GBoolean(false);
+
+    private final boolean value;
+
+    public static GBoolean of(boolean value) {
+        return value? TRUE : FALSE;
+    }
+
+    @Override
+    public boolean getValue() {
+        return value;
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GControl.java

@@ -0,0 +1,37 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.type.EValue;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import static lombok.AccessLevel.PRIVATE;
+
+@RequiredArgsConstructor(access = PRIVATE)
+public final class GControl implements EValue {
+    private static final int BREAK_FLAG = 1;
+    private static final int RETURN_FLAG = 2;
+    public static final GControl BREAK = new GControl(BREAK_FLAG, VOID);
+
+    private final int flag;
+    @Getter private final EValue value;
+
+    public static GControl ofReturn(EValue value) {
+        return new GControl(RETURN_FLAG, value);
+    }
+
+    public boolean isBreak() {
+        return flag == BREAK_FLAG;
+    }
+
+    public boolean isReturn() {
+        return flag == RETURN_FLAG;
+    }
+
+    public EValue toIteration() {
+        return flag == BREAK_FLAG ? VOID : this;
+    }
+
+    public EValue toFunction() {
+        return value;
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GDouble.java

@@ -0,0 +1,18 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.type.EDouble;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@EqualsAndHashCode
+@RequiredArgsConstructor(staticName = "of")
+public final class GDouble implements EDouble {
+    private final double value;
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GFunction.java

@@ -0,0 +1,67 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.internal.engine.Evaluator;
+import com.relogiclabs.jschema.internal.engine.ScopeContext;
+import com.relogiclabs.jschema.type.EValue;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.List;
+
+import static com.relogiclabs.jschema.internal.engine.ScriptTreeHelper.areCompatible;
+import static com.relogiclabs.jschema.internal.util.CollectionHelper.getLast;
+import static com.relogiclabs.jschema.internal.util.CollectionHelper.subList;
+import static com.relogiclabs.jschema.internal.util.MiscellaneousHelper.hasFlag;
+import static com.relogiclabs.jschema.message.ErrorCode.FUNS05;
+
+@Getter
+@RequiredArgsConstructor
+public final class GFunction implements RFunction {
+    public static final String CONSTRAINT_MARKER = "@";
+    public static final int CONSTRAINT_MODE = 1;
+    public static final int FUTURE_MODE = 3;
+    public static final int SUBROUTINE_MODE = 4;
+
+    private final GParameter[] parameters;
+    private final boolean variadic;
+    private final Evaluator body;
+    private final int mode;
+
+    public GFunction(GParameter[] parameters, Evaluator body, int mode) {
+        this.parameters = parameters;
+        this.body = body;
+        this.mode = mode;
+        this.variadic = parameters.length != 0 && getLast(parameters).isVariadic();
+    }
+
+    @Override
+    public EValue invoke(ScopeContext functionScope, List<EValue> arguments) {
+        return invoke(functionScope);
+    }
+
+    public EValue invoke(ScopeContext functionScope) {
+        var v1 = getBody().evaluate(functionScope);
+        if(v1 instanceof GControl ctrl) return ctrl.getValue();
+        return VOID;
+    }
+
+    @Override
+    public ScopeContext bind(ScopeContext parentScope, List<EValue> arguments) {
+        areCompatible(parameters, arguments, FUNS05);
+        var scope = new ScopeContext(parentScope);
+        var i = 0;
+        for(var p : parameters) {
+            if(p.isVariadic()) scope.addVariable(p.getName(), new GArray(subList(arguments, i)));
+            else scope.addVariable(p.getName(), arguments.get(i++));
+        }
+        return scope;
+    }
+
+    public boolean isFuture() {
+        return hasFlag(mode, FUTURE_MODE);
+    }
+
+    public static boolean isConstraint(int mode) {
+        return hasFlag(mode, CONSTRAINT_MODE);
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GInteger.java

@@ -0,0 +1,33 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.type.EInteger;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import static lombok.AccessLevel.PRIVATE;
+
+@Getter
+@EqualsAndHashCode
+@RequiredArgsConstructor(access = PRIVATE)
+public final class GInteger implements EInteger {
+    private static final int CACHE_SIZE = 256;
+    private static final GInteger[] CACHE = createCache(CACHE_SIZE);
+    private final long value;
+
+    public static GInteger of(long value) {
+        if(value >= 0 && value < CACHE_SIZE) return CACHE[(int) value];
+        return new GInteger(value);
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+
+    private static GInteger[] createCache(int size) {
+        GInteger[] cache = new GInteger[size];
+        for(int i = 0; i < size; i++) cache[i] = new GInteger(i);
+        return cache;
+    }
+}

src/main/java/com/relogiclabs/jschema/internal/script/GIterator.java

@@ -0,0 +1,87 @@
+package com.relogiclabs.jschema.internal.script;
+
+import com.relogiclabs.jschema.exception.ScriptCommonException;
+import com.relogiclabs.jschema.type.EArray;
+import com.relogiclabs.jschema.type.EObject;
+import com.relogiclabs.jschema.type.EString;
+import com.relogiclabs.jschema.type.EValue;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Iterator;
+
+import static com.relogiclabs.jschema.internal.engine.ScriptTreeHelper.dereference;
+import static com.relogiclabs.jschema.internal.util.StringHelper.concat;
+import static com.relogiclabs.jschema.message.ErrorCode.ITER01;
+import static lombok.AccessLevel.PRIVATE;
+
+@Getter
+@RequiredArgsConstructor(access = PRIVATE)
+public final class GIterator implements Iterable<EValue> {
+    private final EValue iterable;
+
+    public static GIterator of(EValue iterable) {
+        return new GIterator(dereference(iterable));
+    }
+
+    @Override
+    public Iterator<EValue> iterator() {
+        if(iterable instanceof EArray array) return iterator(array);
+        if(iterable instanceof EObject object) return iterator(object);
+        if(iterable instanceof EString string) return iterator(string);
+        else throw new ScriptCommonException(ITER01,
+                concat("Invalid type ", iterable.getType(), " for iteration"));
+    }
+
+    public Iterator<EValue> iterator(EArray array) {
+        while(array.size() == 1) {
+            if(array.get(0) instanceof EArray)
+                array = (EArray) array.get(0);
+            else break;
+        }
+        var iterator = array.elements().iterator();
+        return new Iterator<>() {
+            @Override
+            public boolean hasNext() {
+                return iterator.hasNext();
+            }
+
+            @Override
+            public EValue next() {
+                return iterator.next();
+            }
+        };
+    }
+
+    public Iterator<EValue> iterator(EString string) {
+        String value = string.getValue();
+        return new Iterator<>() {
+            private int index = 0;
+
+            @Override
+            public boolean hasNext() {
+                return index < value.length();
+            }
+
+            @Override
+            public EValue next() {
+                return GString.of(value.charAt(index++));
+            }
+        };
+    }
+
+    public Iterator<EValue> iterator(EObject object) {
+        var iterator = object.keySet().iterator();
+        return new Iterator<>() {
+            @Override
+            public boolean hasNext() {
+                return iterator.hasNext();
+            }
+
+            @Override
+            public EValue next() {
+                return GString.of(iterator.next());
+            }
+        };
+    }
+}