1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.collections4.functors;
18
19 import java.io.Serializable;
20 import java.util.Objects;
21
22 import org.apache.commons.collections4.Predicate;
23 import org.apache.commons.collections4.Transformer;
24
25 /**
26 * Transformer implementation that will call one of two closures based on whether a predicate evaluates
27 * as true or false.
28 *
29 * @param <I> The input type for the transformer
30 * @param <O> The output type for the transformer
31 *
32 * @since 4.1
33 */
34 public class IfTransformer<I, O> implements Transformer<I, O>, Serializable {
35
36 /** Serial version UID */
37 private static final long serialVersionUID = 8069309411242014252L;
38
39 /**
40 * Factory method that performs validation.
41 *
42 * @param <I> input type for the transformer
43 * @param <O> output type for the transformer
44 * @param predicate predicate to switch on
45 * @param trueTransformer transformer used if true
46 * @param falseTransformer transformer used if false
47 * @return the {@code if} transformer
48 * @throws NullPointerException if either argument is null
49 */
50 public static <I, O> Transformer<I, O> ifTransformer(final Predicate<? super I> predicate,
51 final Transformer<? super I, ? extends O> trueTransformer,
52 final Transformer<? super I, ? extends O> falseTransformer) {
53 return new IfTransformer<>(Objects.requireNonNull(predicate, "predicate"),
54 Objects.requireNonNull(trueTransformer, "trueTransformer"),
55 Objects.requireNonNull(falseTransformer, "falseTransformer"));
56 }
57 /**
58 * Factory method that performs validation.
59 * <p>
60 * This factory creates a transformer that just returns the input object when
61 * the predicate is false.
62 *
63 * @param <T> input and output type for the transformer
64 * @param predicate predicate to switch on
65 * @param trueTransformer transformer used if true
66 * @return the {@code if} transformer
67 * @throws NullPointerException if either argument is null
68 */
69 public static <T> Transformer<T, T> ifTransformer(
70 final Predicate<? super T> predicate,
71 final Transformer<? super T, ? extends T> trueTransformer) {
72 return new IfTransformer<>(Objects.requireNonNull(predicate, "predicate"),
73 Objects.requireNonNull(trueTransformer, "trueTransformer"), NOPTransformer.<T>nopTransformer());
74 }
75 /** The test */
76 private final Predicate<? super I> iPredicate;
77
78 /** The transformer to use if true */
79 private final Transformer<? super I, ? extends O> iTrueTransformer;
80
81 /** The transformer to use if false */
82 private final Transformer<? super I, ? extends O> iFalseTransformer;
83
84 /**
85 * Constructor that performs no validation.
86 * Use the static factory method {@code ifTransformer} if you want that.
87 *
88 * @param predicate predicate to switch on, not null
89 * @param trueTransformer transformer used if true, not null
90 * @param falseTransformer transformer used if false, not null
91 */
92 public IfTransformer(final Predicate<? super I> predicate,
93 final Transformer<? super I, ? extends O> trueTransformer,
94 final Transformer<? super I, ? extends O> falseTransformer) {
95
96 iPredicate = predicate;
97 iTrueTransformer = trueTransformer;
98 iFalseTransformer = falseTransformer;
99 }
100
101 /**
102 * Gets the transformer used when false.
103 *
104 * @return the transformer
105 */
106 public Transformer<? super I, ? extends O> getFalseTransformer() {
107 return iFalseTransformer;
108 }
109
110 /**
111 * Gets the predicate.
112 *
113 * @return the predicate
114 */
115 public Predicate<? super I> getPredicate(){
116 return iPredicate;
117 }
118
119 /**
120 * Gets the transformer used when true.
121 *
122 * @return the transformer
123 */
124 public Transformer<? super I, ? extends O> getTrueTransformer() {
125 return iTrueTransformer;
126 }
127
128 /**
129 * Transforms the input using the true or false transformer based to the result of the predicate.
130 *
131 * @param input the input object to transform
132 * @return the transformed result
133 */
134 @Override
135 public O transform(final I input) {
136 if (iPredicate.evaluate(input)){
137 return iTrueTransformer.transform(input);
138 }
139 return iFalseTransformer.transform(input);
140 }
141 }