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 }