13815628111

Committed 12 Mar 2025 03:46PM CUT coverage: 92.058% (-0.001%) from 92.059%

Build # 13815628111

Build Type

push

github

Committed by

mtf90

Commit Message

cleanup redundant type variable definitions

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

16599 of 18031 relevant lines covered (92.06%)

1.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/commons/util/src/main/java/net/automatalib/common/util/function/FunctionsUtil.java

/* Copyright (C) 2013-2025 TU Dortmund University
 * This file is part of AutomataLib <https://automatalib.net>.
 *
 * 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 net.automatalib.common.util.function;

import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * This class provides utility methods for Java 8 {@link Function} objects (and for the corresponding primitive
 * specializations).
 */
public final class FunctionsUtil {

    private FunctionsUtil() {
        // prevent instantiation
    }

    /**
     * Returns a default function if the argument is {@code null}. The default function's {@code Function#apply(Object)
     * apply} method will always return {@code null}. If a non-{@code null} function is passed to this method, it is
     * returned as-is.
     *
     * @param func
     *         the function reference (may be {@code null})
     * @param <D>
     *         domain type
     * @param <R>
     *         range type
     *
     * @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
     * object always returning {@code null} otherwise
     */
    public static <D, R> Function<D, ? extends @Nullable R> safeDefault(@Nullable Function<D, R> func) {
        if (func == null) {
            return x -> null;
        }
        return func;
    }

    /**
     * Returns a default function if the argument is {@code null}. The default function's {@link IntFunction#apply(int)
     * apply} method will always return {@code null}. If a non-{@code null} function is passed to this method, it is
     * returned as-is.
     *
     * @param func
     *         the function reference (may be {@code null})
     * @param <R>
     *         range type
     *
     * @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
     * object always returning {@code null} otherwise
     */
    public static <R> IntFunction<? extends @Nullable R> safeDefault(@Nullable IntFunction<R> func) {
        if (func == null) {
            return i -> null;
        }
        return func;
    }

    /**
     * Returns a default function if the argument is {@code null}. The default function's {@link
     * BiIntFunction#apply(int, int) apply} method will always return {@code null}. If a non-{@code null} function is
     * passed to this method, it is returned as-is.
     *
     * @param func
     *         the function reference (may be {@code null})
     * @param <R>
     *         range type
     *
     * @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
     * object always returning {@code null} otherwise
     */
    public static <R> BiIntFunction<? extends @Nullable R> safeDefault(@Nullable BiIntFunction<R> func) {
        if (func == null) {
            return (i1, i2) -> null;
        }
        return func;
    }

    public static <T> Predicate<T> safeToTrue(@Nullable Predicate<T> func) {
        if (func == null) {
            return x -> true;
        }
        return func;
    }

    public static <T> Predicate<T> safeToFalse(@Nullable Predicate<T> func) {
        if (func == null) {
            return x -> false;
        }
        return func;
    }

}

1	/* Copyright (C) 2013-2025 TU Dortmund University
2	* This file is part of AutomataLib <https://automatalib.net>.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package net.automatalib.common.util.function;
17
18	import java.util.function.Function;
19	import java.util.function.IntFunction;
20	import java.util.function.Predicate;
21
22	import org.checkerframework.checker.nullness.qual.Nullable;
23
24	/**
25	* This class provides utility methods for Java 8 {@link Function} objects (and for the corresponding primitive
26	* specializations).
27	*/
28	public final class FunctionsUtil {
29
30	private FunctionsUtil() {
31	// prevent instantiation
32	}
33
34	/**
35	* Returns a default function if the argument is {@code null}. The default function's {@code Function#apply(Object)
36	* apply} method will always return {@code null}. If a non-{@code null} function is passed to this method, it is
37	* returned as-is.
38	*
39	* @param func
40	* the function reference (may be {@code null})
41	* @param <D>
42	* domain type
43	* @param <R>
44	* range type
45	*
46	* @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
47	* object always returning {@code null} otherwise
48	*/
49	public static <D, R> Function<D, ? extends @Nullable R> safeDefault(@Nullable Function<D, R> func) {
50	if (func == null) {	×
51	return x -> null;	×
52	}
53	return func;	×
54	}
55
56	/**
57	* Returns a default function if the argument is {@code null}. The default function's {@link IntFunction#apply(int)
58	* apply} method will always return {@code null}. If a non-{@code null} function is passed to this method, it is
59	* returned as-is.
60	*
61	* @param func
62	* the function reference (may be {@code null})
63	* @param <R>
64	* range type
65	*
66	* @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
67	* object always returning {@code null} otherwise
68	*/
69	public static <R> IntFunction<? extends @Nullable R> safeDefault(@Nullable IntFunction<R> func) {
70	if (func == null) {	×
71	return i -> null;	×
72	}
73	return func;	×
74	}
75
76	/**
77	* Returns a default function if the argument is {@code null}. The default function's {@link
78	* BiIntFunction#apply(int, int) apply} method will always return {@code null}. If a non-{@code null} function is
79	* passed to this method, it is returned as-is.
80	*
81	* @param func
82	* the function reference (may be {@code null})
83	* @param <R>
84	* range type
85	*
86	* @return a non-{@code null} object identical to the passed function, if it is non-{@code null}, or a function
87	* object always returning {@code null} otherwise
88	*/
89	public static <R> BiIntFunction<? extends @Nullable R> safeDefault(@Nullable BiIntFunction<R> func) {
90	if (func == null) {	×
91	return (i1, i2) -> null;	×
92	}
93	return func;	×
94	}
95
96	public static <T> Predicate<T> safeToTrue(@Nullable Predicate<T> func) {
97	if (func == null) {	×
98	return x -> true;	×
99	}
100	return func;	×
101	}
102
103	public static <T> Predicate<T> safeToFalse(@Nullable Predicate<T> func) {
104	if (func == null) {	×
105	return x -> false;	×
106	}
107	return func;	×
108	}
109
110	}

LearnLib / automatalib / 13815628111

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous