From a05e9e55e3ea76b036f3daf13bc448b83ad23db0 Mon Sep 17 00:00:00 2001
From: aNNiMON <annimon119@gmail.com>
Date: Sat, 14 Oct 2023 00:09:08 +0300
Subject: [PATCH] [java] Add Boolean converter to Value, add collections
 example

---
 examples/java/collections.own                 | 44 ++++++++++++++++++
 .../annimon/ownlang/modules/java/java.java    |  9 +++-
 .../test/resources/benchmarks/calculator.own  | 45 +++++++++++++++++++
 3 files changed, 96 insertions(+), 2 deletions(-)
 create mode 100644 examples/java/collections.own
 create mode 100644 ownlang-parser/src/test/resources/benchmarks/calculator.own

diff --git a/examples/java/collections.own b/examples/java/collections.own
new file mode 100644
index 0000000..0041a2c
--- /dev/null
+++ b/examples/java/collections.own
@@ -0,0 +1,44 @@
+use java
+
+println "OwnLang array to Java array"
+arr = toObject([1, 2, 4, 2, 0, 4, 3])
+println arr
+
+println "\nArrays.asList"
+Arrays = newClass("java.util.Arrays")
+list1 = Arrays.asList(arr)
+println list1
+
+println "\nStack"
+Stack = newClass("java.util.Stack")
+stack = new Stack()
+stack.push(1)
+stack.push(2)
+stack.push(3)
+println stack.pop()
+println stack.pop()
+
+
+println "\nArrayList from Stack"
+ArrayList = newClass("java.util.ArrayList")
+list2 = new ArrayList(stack)
+list2.add(4)
+for element : list2.toArray() {
+  println element
+}
+
+
+println "\nHashSet"
+HashSet = newClass("java.util.HashSet")
+set = new HashSet(list1)
+println set
+containsFour = set.contains(4)
+// NOTE: containsFour is java.lang.Boolean
+println containsFour.getClass()
+isContainsFour = toValue(containsFour)
+if (isContainsFour) {
+  println "Set contains 4"
+}
+for element : set.toArray() {
+  println element
+}
diff --git a/modules/main/src/main/java/com/annimon/ownlang/modules/java/java.java b/modules/main/src/main/java/com/annimon/ownlang/modules/java/java.java
index 059f405..55eca9d 100644
--- a/modules/main/src/main/java/com/annimon/ownlang/modules/java/java.java
+++ b/modules/main/src/main/java/com/annimon/ownlang/modules/java/java.java
@@ -24,6 +24,8 @@ public final class java implements Module {
     public Map<String, Value> constants() {
         final var result = new LinkedHashMap<String, Value>(16);
         result.put("null", NULL);
+        result.put("TRUE", new ObjectValue(Boolean.TRUE));
+        result.put("FALSE", new ObjectValue(Boolean.FALSE));
         result.put("boolean.class", new ClassValue(boolean.class));
         result.put("boolean[].class", new ClassValue(boolean[].class));
         result.put("boolean[][].class", new ClassValue(boolean[][].class));
@@ -258,8 +260,11 @@ public final class java implements Module {
 
     private Value toValue(Value[] args) {
         Arguments.check(1, args.length);
-        if (args[0] instanceof ObjectValue) {
-            return objectToValue( ((ObjectValue) args[0]).object );
+        if (args[0] instanceof ObjectValue obj) {
+            if (obj.object != null && Boolean.class.isAssignableFrom(obj.object.getClass())) {
+                return NumberValue.fromBoolean((Boolean) obj.object);
+            }
+            return objectToValue(obj.object);
         }
         return NULL;
     }
diff --git a/ownlang-parser/src/test/resources/benchmarks/calculator.own b/ownlang-parser/src/test/resources/benchmarks/calculator.own
new file mode 100644
index 0000000..a4386a8
--- /dev/null
+++ b/ownlang-parser/src/test/resources/benchmarks/calculator.own
@@ -0,0 +1,45 @@
+// Simple parser example
+use std, types
+
+operations = {
+  "+" : def(a,b) = a+b,
+  "-" : def(a,b) = a-b,
+  "*" : def(a,b) = a*b,
+  "/" : def(a,b) = a/b,
+  "%" : def(a,b) = a%b,
+  ">" : def(a,b) = a>b,
+  "<" : def(a,b) = a<b
+}
+
+def calculate(expression) {
+  pos = 0
+  len = length(expression)
+
+  def isDigit(c) = 48 <= c && c <= 57
+
+  def parseNumber() {
+    buffer = ""
+    while (pos < len && isDigit(expression.charAt(pos))) {
+      buffer += toChar(expression.charAt(pos))
+      pos++
+    }
+    return number(buffer)
+  }
+
+  def parseOperation() {
+    while (pos < len && !arrayKeyExists(toChar(expression.charAt(pos)), operations)) {
+      pos++
+    }
+    return operations[toChar(expression.charAt(pos++))]
+  }
+
+  num1 = parseNumber()
+  op = parseOperation()
+  num2 = parseNumber()
+  return op(num1, num2)
+}
+
+x = calculate("2+2")
+ + calculate("400*16")
+ + calculate("400/160")
+ + calculate("3>4")