12893661530

Committed 21 Jan 2025 06:40PM UTC coverage: 50.829%. Remained the same

Build # 12893661530

Build Type

push

github

Committed by

torand

Commit Message

refactor: rename expression -> condition

Run Details

104 of 304 branches covered (34.21%)

Branch coverage included in aggregate %.

81 of 211 new or added lines in 24 files covered. (38.39%)

3 existing lines in 2 files now uncovered.

601 of 1083 relevant lines covered (55.49%)

2.91 hits per line

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

14.29

/src/main/java/io/github/torand/fastersql/condition/OptionalCondition.java

/*
 * Copyright (c) 2024 Tore Eide Andersen
 *
 * 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 io.github.torand.fastersql.condition;

import io.github.torand.fastersql.condition.logical.LogicalConditions;

import java.util.Collection;
import java.util.stream.Stream;

import static io.github.torand.fastersql.util.collection.CollectionHelper.streamSafely;
import static io.github.torand.fastersql.util.contract.Requires.precondition;
import static java.util.Objects.nonNull;
import static java.util.Objects.requireNonNull;

public class OptionalCondition {
    private final Condition condition;

    public static OptionalCondition of(Condition condition) {
        requireNonNull(condition, "condition");
        return new OptionalCondition(condition);
    }

    public static OptionalCondition ofNullable(Condition condition) {
        return new OptionalCondition(condition);
    }

    public static OptionalCondition empty() {
        return new OptionalCondition(null);
    }

    private OptionalCondition(Condition condition) {
        this.condition = condition;
    }

    public boolean isPresent() {
        return nonNull(condition);
    }

    public Condition get() {
        precondition(() -> nonNull(condition), "Condition is not present");
        return condition;
    }

    public Stream<Condition> stream() {
        return nonNull(condition) ? Stream.of(condition) : Stream.empty();
    }

    public OptionalCondition or(Condition other) {
        requireNonNull(other, "other");

        if (nonNull(this.condition)) {
            return new OptionalCondition(LogicalConditions.or(this.condition, other));
        } else {
            return new OptionalCondition(other);
        }
    }

    public OptionalCondition or(OptionalCondition other) {
        if (nonNull(this.condition) && nonNull(other.condition)) {
            return new OptionalCondition(LogicalConditions.or(this.condition, other.condition));
        } else if (nonNull(this.condition)) {
            return new OptionalCondition(this.condition);
        } else if (nonNull(other.condition)) {
            return new OptionalCondition(other.condition);
        } else {
            return new OptionalCondition(null);
        }
    }

    public OptionalCondition and(OptionalCondition other) {
        if (nonNull(this.condition) && nonNull(other.condition)) {
            return new OptionalCondition(LogicalConditions.and(this.condition, other.condition));
        } else if (nonNull(this.condition)) {
            return new OptionalCondition(this.condition);
        } else if (nonNull(other.condition)) {
            return new OptionalCondition(other.condition);
        } else {
            return new OptionalCondition(null);
        }
    }

    public OptionalCondition and(Condition other) {
        requireNonNull(other, "other");

        if (nonNull(this.condition)) {
            return new OptionalCondition(LogicalConditions.and(this.condition, other));
        } else {
            return new OptionalCondition(other);
        }
    }

    public static Collection<Condition> unwrap(OptionalCondition... maybeConditions) {
        return streamSafely(maybeConditions).flatMap(OptionalCondition::stream).toList();
    }
}

1	/*
2	* Copyright (c) 2024 Tore Eide Andersen
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 io.github.torand.fastersql.condition;
17
18	import io.github.torand.fastersql.condition.logical.LogicalConditions;
19
20	import java.util.Collection;
21	import java.util.stream.Stream;
22
23	import static io.github.torand.fastersql.util.collection.CollectionHelper.streamSafely;
24	import static io.github.torand.fastersql.util.contract.Requires.precondition;
25	import static java.util.Objects.nonNull;
26	import static java.util.Objects.requireNonNull;
27
28	public class OptionalCondition {
29	private final Condition condition;
30
31	public static OptionalCondition of(Condition condition) {
NEW 32	requireNonNull(condition, "condition");	×
NEW 33	return new OptionalCondition(condition);	×
34	}
35
36	public static OptionalCondition ofNullable(Condition condition) {
37	return new OptionalCondition(condition);	5✔
38	}
39
40	public static OptionalCondition empty() {
NEW 41	return new OptionalCondition(null);	×
42	}
43
44	private OptionalCondition(Condition condition) {	2✔
45	this.condition = condition;	3✔
46	}	1✔
47
48	public boolean isPresent() {
NEW 49	return nonNull(condition);	×
50	}
51
52	public Condition get() {
NEW 53	precondition(() -> nonNull(condition), "Condition is not present");	×
NEW 54	return condition;	×
55	}
56
57	public Stream<Condition> stream() {
58	return nonNull(condition) ? Stream.of(condition) : Stream.empty();	10✔
59	}
60
61	public OptionalCondition or(Condition other) {
NEW 62	requireNonNull(other, "other");	×
63
NEW 64	if (nonNull(this.condition)) {	×
NEW 65	return new OptionalCondition(LogicalConditions.or(this.condition, other));	×
66	} else {
NEW 67	return new OptionalCondition(other);	×
68	}
69	}
70
71	public OptionalCondition or(OptionalCondition other) {
NEW 72	if (nonNull(this.condition) && nonNull(other.condition)) {	×
NEW 73	return new OptionalCondition(LogicalConditions.or(this.condition, other.condition));	×
NEW 74	} else if (nonNull(this.condition)) {	×
NEW 75	return new OptionalCondition(this.condition);	×
NEW 76	} else if (nonNull(other.condition)) {	×
NEW 77	return new OptionalCondition(other.condition);	×
78	} else {
NEW 79	return new OptionalCondition(null);	×
80	}
81	}
82
83	public OptionalCondition and(OptionalCondition other) {
NEW 84	if (nonNull(this.condition) && nonNull(other.condition)) {	×
NEW 85	return new OptionalCondition(LogicalConditions.and(this.condition, other.condition));	×
NEW 86	} else if (nonNull(this.condition)) {	×
NEW 87	return new OptionalCondition(this.condition);	×
NEW 88	} else if (nonNull(other.condition)) {	×
NEW 89	return new OptionalCondition(other.condition);	×
90	} else {
NEW 91	return new OptionalCondition(null);	×
92	}
93	}
94
95	public OptionalCondition and(Condition other) {
NEW 96	requireNonNull(other, "other");	×
97
NEW 98	if (nonNull(this.condition)) {	×
NEW 99	return new OptionalCondition(LogicalConditions.and(this.condition, other));	×
100	} else {
NEW 101	return new OptionalCondition(other);	×
102	}
103	}
104
105	public static Collection<Condition> unwrap(OptionalCondition... maybeConditions) {
106	return streamSafely(maybeConditions).flatMap(OptionalCondition::stream).toList();	6✔
107	}
108	}

torand / FasterSQL / 12893661530

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