support & (and) operator, and | (or) operator.

Author: LSafer

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

@@ -0,0 +1,66 @@
+/*
+ *	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 logic evaluates to {@code true} if both two logics evaluates to {@code true}.
+ *
+ * @author LSafer
+ * @version 0.0.4
+ * @since 0.0.4 ~2020.09.22
+ */
+public class And implements Logic {
+	/**
+	 * The logic in the left.
+	 *
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	protected final Logic left;
+	/**
+	 * The logic in the right.
+	 *
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	protected final Logic right;
+
+	/**
+	 * Construct a new {@code and} statement.
+	 *
+	 * @param left  the left logic in the {@code and} statement.
+	 * @param right the right logic in the {@code and} statement.
+	 * @throws NullPointerException if the given {@code left} or {@code right} is null.
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	public And(Logic left, Logic right) {
+		Objects.requireNonNull(left, "left");
+		Objects.requireNonNull(right, "right");
+		this.left = left;
+		this.right = right;
+	}
+
+	@Override
+	public String evaluate(Memory memory) {
+		Objects.requireNonNull(memory, "memory");
+		return this.left.evaluateBoolean(memory) &&
+			   this.right.evaluateBoolean(memory) ?
+			   "true" :
+			   "false";
+	}
+}

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

@@ -0,0 +1,66 @@
+/*
+ *	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 logic evaluates to {@code true} if ether two logics evaluates to {@code true}.
+ *
+ * @author LSafer
+ * @version 0.0.4
+ * @since 0.0.4 ~2020.09.22
+ */
+public class Or implements Logic {
+	/**
+	 * The logic in the left.
+	 *
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	protected final Logic left;
+	/**
+	 * The logic in the right.
+	 *
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	protected final Logic right;
+
+	/**
+	 * Construct a new {@code or} statement.
+	 *
+	 * @param left  the left logic in the {@code or} statement.
+	 * @param right the right logic in the {@code or} statement.
+	 * @throws NullPointerException if the given {@code left} or {@code right} is null.
+	 * @since 0.0.4 ~2020.09.22
+	 */
+	public Or(Logic left, Logic right) {
+		Objects.requireNonNull(left, "left");
+		Objects.requireNonNull(right, "right");
+		this.left = left;
+		this.right = right;
+	}
+
+	@Override
+	public String evaluate(Memory memory) {
+		Objects.requireNonNull(memory, "memory");
+		return this.left.evaluateBoolean(memory) ||
+			   this.right.evaluateBoolean(memory) ?
+			   "true" :
+			   "false";
+	}
+}

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.3
+ * @version 0.0.4
  * @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,8 @@ public void parse(List poll) {
 
 		//clear all negations, equations
 		this.parseNegations(poll);
+		this.parseAnds(poll);
+		this.parseOrs(poll);
 		this.parseEquations(poll);
 	}
 
@@ -110,6 +112,55 @@ public List poll(String string) {
 		return new ArrayList(Collections.singleton(string));
 	}
 
+	/**
+	 * 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}.
+	 * <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 a and</li>
+	 * </ul>
+	 *
+	 * @param poll the poll to parse any and in it.
+	 * @throws NullPointerException if the given {@code poll} is null.
+	 * @throws ParseException       if any parse exception occurs; if an and has no element before
+	 *                              or after it; if an element before or after an and has not been
+	 *                              resolved into a {@link Logic}.
+	 * @since 0.0.1 ~2020.09.19
+	 */
+	protected void parseAnds(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 And(leftLogic, rightLogic);
+
+						iterator.add(logic);
+					} catch (NoSuchElementException | ClassCastException e) {
+						throw new ParseException("Invalid And", e);
+					}
+			}
+		}
+	}
+
 	/**
 	 * Parse any possible {@link Constant}s in the given {@code poll}. After calling this method, no
 	 * constant statement in a {@link String} should remain in the given {@code poll}.
@@ -258,6 +309,55 @@ protected void parseNegations(List poll) {
 		}
 	}
 
+	/**
+	 * Parse any possible {@link Or}s in the given {@code poll}. After calling this method, no or
+	 * 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 or</li>
+	 * </ul>
+	 *
+	 * @param poll the poll to parse any or in it.
+	 * @throws NullPointerException if the given {@code poll} is null.
+	 * @throws ParseException       if any parse exception occurs; if an or has no element before or
+	 *                              after it; if an element before or after an or has not been
+	 *                              resolved into a {@link Logic}.
+	 * @since 0.0.1 ~2020.09.19
+	 */
+	protected void parseOrs(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 Or(leftLogic, rightLogic);
+
+						iterator.add(logic);
+					} catch (NoSuchElementException | ClassCastException e) {
+						throw new ParseException("Invalid Equation", e);
+					}
+			}
+		}
+	}
+
 	/**
 	 * Parse any possible {@link Reference} in the given {@code poll}. After calling this method, no
 	 * reference statement in a {@link String} should remain in the given {@code poll}.