001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.functor.core.composite;
018
019 import org.apache.commons.functor.BinaryFunction;
020 import org.apache.commons.functor.BinaryPredicate;
021 import org.apache.commons.functor.BinaryProcedure;
022 import org.apache.commons.functor.Function;
023 import org.apache.commons.functor.Predicate;
024 import org.apache.commons.functor.Procedure;
025 import org.apache.commons.functor.UnaryFunction;
026 import org.apache.commons.functor.UnaryPredicate;
027 import org.apache.commons.functor.UnaryProcedure;
028
029 /**
030 * Utility methods for creating conditional functors.
031 * @version $Revision: 1166380 $ $Date: 2011-09-07 22:18:14 +0200 (Wed, 07 Sep 2011) $
032 * @author Rodney Waldhoff
033 */
034 public final class Conditional {
035
036 // constructor - for beanish apis
037 // ------------------------------------------------------------------------
038
039 /**
040 * <p>{@code Conditional} instances should NOT be constructed in
041 * standard programming. Instead, the methods of the class should be invoked
042 * statically.</p>
043 *
044 * <p>This constructor is public to permit tools that require a JavaBean
045 * instance to operate.</p>
046 */
047 public Conditional() { }
048
049 // ------------------------------------------------------------------------
050
051 /**
052 * Create a guarded Procedure.
053 * @param q if
054 * @param r then
055 * @return Procedure
056 */
057 public static Procedure procedure(Predicate q, Procedure r) {
058 return new ConditionalProcedure(q, r);
059 }
060
061 /**
062 * Create a conditional Procedure.
063 * @param q if
064 * @param r then
065 * @param s else
066 * @return Procedure
067 */
068 public static Procedure procedure(Predicate q, Procedure r, Procedure s) {
069 return new ConditionalProcedure(q, r, s);
070 }
071
072 /**
073 * Create a conditional Function.
074 * @param q if
075 * @param r then
076 * @param s else
077 * @return Function<T>
078 */
079 public static <T> Function<T> function(Predicate q, Function<? extends T> r, Function<? extends T> s) {
080 return new ConditionalFunction<T>(q, r, s);
081 }
082
083 /**
084 * Create a conditional Predicate.
085 * @param q if
086 * @param r then
087 * @param s else
088 * @return Predicate
089 */
090 public static Predicate predicate(Predicate q, Predicate r, Predicate s) {
091 return new ConditionalPredicate(q, r, s);
092 }
093
094 /**
095 * Create a guarded UnaryProcedure.
096 * @param q if
097 * @param r then
098 * @return UnaryProcedure<A>
099 */
100 public static <A> UnaryProcedure<A> procedure(UnaryPredicate<? super A> q, UnaryProcedure<? super A> r) {
101 return new ConditionalUnaryProcedure<A>(q, r);
102 }
103
104 /**
105 * Create a conditional UnaryProcedure.
106 * @param q if
107 * @param r then
108 * @param s else
109 * @return UnaryProcedure<A>
110 */
111 public static <A> UnaryProcedure<A> procedure(UnaryPredicate<? super A> q, UnaryProcedure<? super A> r,
112 UnaryProcedure<? super A> s) {
113 return new ConditionalUnaryProcedure<A>(q, r, s);
114 }
115
116 /**
117 * Create a conditional UnaryFunction.
118 * @param q if
119 * @param r then
120 * @param s else
121 * @return UnaryFunction<A, T>
122 */
123 public static <A, T> UnaryFunction<A, T> function(UnaryPredicate<? super A> q,
124 UnaryFunction<? super A, ? extends T> r, UnaryFunction<? super A, ? extends T> s) {
125 return new ConditionalUnaryFunction<A, T>(q, r, s);
126 }
127
128 /**
129 * Create a conditional UnaryPredicate.
130 * @param q if
131 * @param r then
132 * @param s else
133 * @return UnaryPredicate<A>
134 */
135 public static <A> UnaryPredicate<A> predicate(UnaryPredicate<? super A> q, UnaryPredicate<? super A> r,
136 UnaryPredicate<? super A> s) {
137 return new ConditionalUnaryPredicate<A>(q, r, s);
138 }
139
140 /**
141 * Create a guarded BinaryProcedure.
142 * @param q if
143 * @param r then
144 * @return BinaryProcedure<L, R>
145 */
146 public static <L, R> BinaryProcedure<L, R> procedure(BinaryPredicate<? super L, ? super R> q,
147 BinaryProcedure<? super L, ? super R> r) {
148 return new ConditionalBinaryProcedure<L, R>(q, r);
149 }
150
151 /**
152 * Create a conditional BinaryProcedure.
153 * @param q if
154 * @param r then
155 * @param s else
156 * @return BinaryProcedure<L, R>
157 */
158 public static <L, R> BinaryProcedure<L, R> procedure(BinaryPredicate<? super L, ? super R> q,
159 BinaryProcedure<? super L, ? super R> r, BinaryProcedure<? super L, ? super R> s) {
160 return new ConditionalBinaryProcedure<L, R>(q, r, s);
161 }
162
163 /**
164 * Create a conditional BinaryFunction.
165 * @param q if
166 * @param r then
167 * @param s else
168 * @return BinaryFunction<L, R, T>
169 */
170 public static <L, R, T> BinaryFunction<L, R, T> function(BinaryPredicate<? super L, ? super R> q,
171 BinaryFunction<? super L, ? super R, ? extends T> r, BinaryFunction<? super L, ? super R, ? extends T> s) {
172 return new ConditionalBinaryFunction<L, R, T>(q, r, s);
173 }
174
175 /**
176 * Create a conditional BinaryPredicate.
177 * @param q if
178 * @param r then
179 * @param s else
180 * @return BinaryPredicate<L, R>
181 */
182 public static <L, R> BinaryPredicate<L, R> predicate(BinaryPredicate<? super L, ? super R> q,
183 BinaryPredicate<? super L, ? super R> r, BinaryPredicate<? super L, ? super R> s) {
184 return new ConditionalBinaryPredicate<L, R>(q, r, s);
185 }
186
187 }