-/*******************************************************************************\r
- * Copyright (c) 2016 Association for Decentralized Information Management\r
- * in Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * Semantum Oy - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.db.function;\r
-\r
-import java.util.Objects;\r
-\r
-import org.simantics.db.exception.DatabaseException;\r
-\r
-/**\r
- * Represents a predicate (boolean-valued function) of one argument that can\r
- * throw database exceptions.\r
- *\r
- * @param <T>\r
- * the type of the input to the predicate\r
- *\r
- * @author Tuukka Lehtonen\r
- * @since 1.22.1 & 1.24.0\r
- */\r
-@FunctionalInterface\r
-public interface DbPredicate<T> {\r
-\r
- /**\r
- * Evaluates this predicate on the given argument.\r
- *\r
- * @param t the input argument\r
- * @return {@code true} if the input argument matches the predicate,\r
- * otherwise {@code false}\r
- */\r
- boolean test(T t) throws DatabaseException;\r
-\r
- /**\r
- * Returns a composed predicate that represents a short-circuiting logical\r
- * AND of this predicate and another. When evaluating the composed\r
- * predicate, if this predicate is {@code false}, then the {@code other}\r
- * predicate is not evaluated.\r
- *\r
- * <p>Any exceptions thrown during evaluation of either predicate are relayed\r
- * to the caller; if evaluation of this predicate throws an exception, the\r
- * {@code other} predicate will not be evaluated.\r
- *\r
- * @param other a predicate that will be logically-ANDed with this\r
- * predicate\r
- * @return a composed predicate that represents the short-circuiting logical\r
- * AND of this predicate and the {@code other} predicate\r
- * @throws NullPointerException if other is null\r
- */\r
- default DbPredicate<T> and(DbPredicate<? super T> other) {\r
- Objects.requireNonNull(other);\r
- return (t) -> test(t) && other.test(t);\r
- }\r
-\r
- /**\r
- * Returns a predicate that represents the logical negation of this\r
- * predicate.\r
- *\r
- * @return a predicate that represents the logical negation of this\r
- * predicate\r
- */\r
- default DbPredicate<T> negate() {\r
- return (t) -> !test(t);\r
- }\r
-\r
- /**\r
- * Returns a composed predicate that represents a short-circuiting logical\r
- * OR of this predicate and another. When evaluating the composed\r
- * predicate, if this predicate is {@code true}, then the {@code other}\r
- * predicate is not evaluated.\r
- *\r
- * <p>Any exceptions thrown during evaluation of either predicate are relayed\r
- * to the caller; if evaluation of this predicate throws an exception, the\r
- * {@code other} predicate will not be evaluated.\r
- *\r
- * @param other a predicate that will be logically-ORed with this\r
- * predicate\r
- * @return a composed predicate that represents the short-circuiting logical\r
- * OR of this predicate and the {@code other} predicate\r
- * @throws NullPointerException if other is null\r
- */\r
- default DbPredicate<T> or(DbPredicate<? super T> other) {\r
- Objects.requireNonNull(other);\r
- return (t) -> test(t) || other.test(t);\r
- }\r
-\r
- /**\r
- * Returns a predicate that tests if two arguments are equal according\r
- * to {@link Objects#equals(Object, Object)}.\r
- *\r
- * @param <T> the type of arguments to the predicate\r
- * @param targetRef the object reference with which to compare for equality,\r
- * which may be {@code null}\r
- * @return a predicate that tests if two arguments are equal according\r
- * to {@link Objects#equals(Object, Object)}\r
- */\r
- static <T> DbPredicate<T> isEqual(Object targetRef) {\r
- return (null == targetRef)\r
- ? Objects::isNull\r
- : object -> targetRef.equals(object);\r
- }\r
-\r
-}\r
+/*******************************************************************************
+ * Copyright (c) 2016 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.function;
+
+import java.util.Objects;
+
+import org.simantics.db.exception.DatabaseException;
+
+/**
+ * Represents a predicate (boolean-valued function) of one argument that can
+ * throw database exceptions.
+ *
+ * @param <T>
+ * the type of the input to the predicate
+ *
+ * @author Tuukka Lehtonen
+ * @since 1.22.1 & 1.24.0
+ */
+@FunctionalInterface
+public interface DbPredicate<T> {
+
+ /**
+ * Evaluates this predicate on the given argument.
+ *
+ * @param t the input argument
+ * @return {@code true} if the input argument matches the predicate,
+ * otherwise {@code false}
+ */
+ boolean test(T t) throws DatabaseException;
+
+ /**
+ * Returns a composed predicate that represents a short-circuiting logical
+ * AND of this predicate and another. When evaluating the composed
+ * predicate, if this predicate is {@code false}, then the {@code other}
+ * predicate is not evaluated.
+ *
+ * <p>Any exceptions thrown during evaluation of either predicate are relayed
+ * to the caller; if evaluation of this predicate throws an exception, the
+ * {@code other} predicate will not be evaluated.
+ *
+ * @param other a predicate that will be logically-ANDed with this
+ * predicate
+ * @return a composed predicate that represents the short-circuiting logical
+ * AND of this predicate and the {@code other} predicate
+ * @throws NullPointerException if other is null
+ */
+ default DbPredicate<T> and(DbPredicate<? super T> other) {
+ Objects.requireNonNull(other);
+ return (t) -> test(t) && other.test(t);
+ }
+
+ /**
+ * Returns a predicate that represents the logical negation of this
+ * predicate.
+ *
+ * @return a predicate that represents the logical negation of this
+ * predicate
+ */
+ default DbPredicate<T> negate() {
+ return (t) -> !test(t);
+ }
+
+ /**
+ * Returns a composed predicate that represents a short-circuiting logical
+ * OR of this predicate and another. When evaluating the composed
+ * predicate, if this predicate is {@code true}, then the {@code other}
+ * predicate is not evaluated.
+ *
+ * <p>Any exceptions thrown during evaluation of either predicate are relayed
+ * to the caller; if evaluation of this predicate throws an exception, the
+ * {@code other} predicate will not be evaluated.
+ *
+ * @param other a predicate that will be logically-ORed with this
+ * predicate
+ * @return a composed predicate that represents the short-circuiting logical
+ * OR of this predicate and the {@code other} predicate
+ * @throws NullPointerException if other is null
+ */
+ default DbPredicate<T> or(DbPredicate<? super T> other) {
+ Objects.requireNonNull(other);
+ return (t) -> test(t) || other.test(t);
+ }
+
+ /**
+ * Returns a predicate that tests if two arguments are equal according
+ * to {@link Objects#equals(Object, Object)}.
+ *
+ * @param <T> the type of arguments to the predicate
+ * @param targetRef the object reference with which to compare for equality,
+ * which may be {@code null}
+ * @return a predicate that tests if two arguments are equal according
+ * to {@link Objects#equals(Object, Object)}
+ */
+ static <T> DbPredicate<T> isEqual(Object targetRef) {
+ return (null == targetRef)
+ ? Objects::isNull
+ : object -> targetRef.equals(object);
+ }
+
+}
Code Review / simantics / platform.git / blobdiff