Added the + (addition) operator

Author: LSafer

src/main/java/org/jamplate/logic/Addition.java

@@ -0,0 +1,99 @@
+/*
+ *	Copyright 2020 Cufy
+ *
+ *	Licensed under the Apache License, Version 2.0 (the "License");
+ *	you may not use this file except in compliance with the License.
+ *	You may obtain a copy of the License at
+ *
+ *	    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *	Unless required by applicable law or agreed to in writing, software
+ *	distributed under the License is distributed on an "AS IS" BASIS,
+ *	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *	See the License for the specific language governing permissions and
+ *	limitations under the License.
+ */
+package org.jamplate.logic;
+
+import org.jamplate.memory.Memory;
+
+import java.util.Objects;
+
+/**
+ * A scope that joins two logics.
+ *
+ * @author LSafer
+ * @version 0.0.6
+ * @since 0.0.6 ~2020.09.22
+ */
+public class Addition implements Logic {
+	/**
+	 * The logic at the left.
+	 *
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	protected final Logic left;
+	/**
+	 * The logic at the right.
+	 *
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	protected final Logic right;
+
+	/**
+	 * Construct a new logic that joins two logics.
+	 *
+	 * @param left  the logic at the left.
+	 * @param right the logic at the right.
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	public Addition(Logic left, Logic right) {
+		Objects.requireNonNull(left, "left");
+		Objects.requireNonNull(right, "right");
+		this.left = left;
+		this.right = right;
+	}
+
+	/**
+	 * Get the {@link #left} logic of this.
+	 *
+	 * @return the {@link #left} logic of this.
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	public final Logic left() {
+		return this.left;
+	}
+
+	/**
+	 * Get the {@link #right} logic of this.
+	 *
+	 * @return the {@link #right} logic of this.
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	public final Logic right() {
+		return this.right;
+	}
+
+	@Override
+	public String evaluate(Memory memory) {
+		Objects.requireNonNull(memory, "memory");
+		String left = this.left.evaluate(memory);
+		String right = this.right.evaluate(memory);
+
+		//double join
+		if (left.matches("^\\d*[.]\\d*$") &&
+			right.matches("^\\d*[.]\\d*$"))
+			return String.valueOf(
+					Double.parseDouble(left) +
+					Double.parseDouble(right)
+			);
+		else if (left.matches("^\\d*$") &&
+				 right.matches("^\\d*$"))
+			return String.valueOf(
+					Long.parseLong(left) +
+					Long.parseLong(right)
+			);
+
+		return left + right;
+	}
+}

src/main/java/org/jamplate/parser/LogicParser.java

@@ -26,7 +26,7 @@
  * The default jamplate parser that parses {@link String}s into {@link Logic}s.
  *
  * @author LSafer
- * @version 0.0.4
+ * @version 0.0.6
  * @since 0.0.1 ~2020.09.19
  */
 public class LogicParser implements PollParser<Logic> {
@@ -65,7 +65,7 @@ public class LogicParser implements PollParser<Logic> {
 	 *
 	 * @since 0.0.1 ~2020.09.19
 	 */
-	protected final Pattern PATTERN_WHITESPACES = Pattern.compile("(\\s+)|[|]|[&]|(!=)|(==)|(!(?!=))");
+	protected final Pattern PATTERN_WHITESPACES = Pattern.compile("(\\s+)|[|]|[+]|[&]|(!=)|(==)|(!(?!=))");
 
 	@Override
 	public Logic link(List poll) {
@@ -101,6 +101,7 @@ public void parse(List poll) {
 
 		//clear all negations, equations
 		this.parseNegations(poll);
+		this.parseAdditions(poll);
 		this.parseAnds(poll);
 		this.parseOrs(poll);
 		this.parseEquations(poll);
@@ -112,6 +113,55 @@ public List poll(String string) {
 		return new ArrayList(Collections.singleton(string));
 	}
 
+	/**
+	 * Parse any possible {@link Addition}s in the given {@code poll}. After calling this method, no
+	 * addition statement in a {@link String} should remain in the given {@code poll}.
+	 * <p>
+	 * Clear these before calling this method:
+	 * <ul>
+	 *     <li>{@link #processParenthesis(List)}</li>
+	 *     <li>{@link #parseConstants(List)}</li>
+	 *     <li>{@link #parseReferences(List)}</li>
+	 *     <li>{@link #processWhitespaces(List)}</li>
+	 *     <li>{@link #parseNegations(List)}</li>
+	 *     <li>any statement that could be before or next to an addition</li>
+	 * </ul>
+	 *
+	 * @param poll the poll to parse any addition in it.
+	 * @throws NullPointerException if the given {@code poll} is null.
+	 * @throws ParseException       if any parse exception occurs; if an addition has no element
+	 *                              before or after it; if an element before or after an addition
+	 *                              has not been resolved into a {@link Logic}.
+	 * @since 0.0.6 ~2020.09.22
+	 */
+	protected void parseAdditions(List poll) {
+		Objects.requireNonNull(poll, "poll");
+
+		ListIterator iterator = poll.listIterator();
+		while (iterator.hasNext()) {
+			Object next = iterator.next();
+
+			if (next instanceof String) {
+				String string = (String) next;
+
+				if (string.equals("+"))
+					try {
+						iterator.remove();
+						Logic rightLogic = (Logic) iterator.next();
+						iterator.remove();
+						Logic leftLogic = (Logic) iterator.previous();
+						iterator.remove();
+
+						Logic logic = new Addition(leftLogic, rightLogic);
+
+						iterator.add(logic);
+					} catch (NoSuchElementException | ClassCastException e) {
+						throw new ParseException("Invalid Addition", e);
+					}
+			}
+		}
+	}
+
 	/**
 	 * Parse any possible {@link And}s in the given {@code poll}. After calling this method, no and
 	 * statement in a {@link String} should remain in the given {@code poll}.