KezvhLib/src-lib/net/kezvh/functional/Operations.java

   1 package net.kezvh.functional;
   2
   3 import java.util.Collection;
   4 import java.util.Iterator;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7
   8 import net.kezvh.collections.DualMap.DualMap;
   9 import net.kezvh.functional.lambda.L0;
  10 import net.kezvh.functional.lambda.L1;
  11 import net.kezvh.functional.lambda.L2;
  12 import net.kezvh.functional.lambda.Predicate2;
  13 import net.kezvh.lang.UtilityClass;
  14
  15 /**
  16  * @author afflux
  17  */
  18 public final class Operations extends UtilityClass {
  19         /**
  20          *
  21          */
  22         public static final Predicate2<?, ?> EQUALS = new Predicate2<Object, Object>() {
  23                 /**
  24                  * @see net.kezvh.functional.lambda.L2#op(java.lang.Object,
  25                  *      java.lang.Object)
  26                  * @param param1 param1
  27                  * @param param2 param2
  28                  * @return x
  29                  */
  30                 @Override
  31                 public Boolean op(final Object param1, final Object param2) {
  32                         return (param1 == null) ? param2 == null : param1.equals(param2);
  33                 }
  34         };
  35
  36         /**
  37          * @param <K> key type
  38          * @param <V> value type
  39          * @return function which returns the value of a map entry
  40          */
  41         public static <K, V> L1<V, Map.Entry<K, V>> getValue() {
  42                 return new L1<V, Entry<K, V>>() {
  43                         @Override
  44                         public V op(final Entry<K, V> arg0) {
  45                                 return arg0.getValue();
  46                         }
  47                 };
  48         }
  49
  50         /**
  51          * @param <K> key type
  52          * @param <V> value type
  53          * @return function which returns the value of a map entry
  54          */
  55         public static <K, V> L1<K, Map.Entry<K, V>> getKey() {
  56                 return new L1<K, Entry<K, V>>() {
  57                         @Override
  58                         public K op(final Entry<K, V> arg0) {
  59                                 return arg0.getKey();
  60                         }
  61                 };
  62         }
  63
  64         /**
  65          * @param <T> COMMENT
  66          * @return COMMENT
  67          */
  68         @SuppressWarnings("unchecked")
  69         public static final <T> Predicate2<T, T> equals() {
  70                 return (Predicate2<T, T>) Operations.EQUALS;
  71         }
  72
  73         /**
  74          * @param <T> COMMENT
  75          * @param t COMMENT
  76          * @return COMMENT
  77          */
  78         public static final <T> L0<T> constant0(final T t) {
  79                 return new L0<T>() {
  80                         @Override
  81                         public T op() {
  82                                 return t;
  83                         }
  84                 };
  85         }
  86
  87         /**
  88          * @param <S> COMMENT
  89          * @param <T> COMMENT
  90          * @param s COMMENT
  91          * @return COMMENT
  92          */
  93         public static final <S, T> L1<S, T> constant1(final S s) {
  94                 return new L1<S, T>() {
  95                         public S op(final T param) {
  96                                 return s;
  97                         }
  98                 };
  99         }
 100
 101         /**
 102          * @param <S> COMMENT
 103          * @param <T> COMMENT
 104          * @param <U> COMMENT
 105          * @param s COMMENT
 106          * @return COMMENT
 107          */
 108         public static final <S, T, U> L2<S, T, U> constant2(final S s) {
 109                 return new L2<S, T, U>() {
 110                         public S op(final T param, final U param2) {
 111                                 return s;
 112                         }
 113                 };
 114         }
 115
 116         /**
 117          * @param <S> COMMENT
 118          * @param <T> COMMENT
 119          * @param <U> COMMENT
 120          * @param a COMMENT
 121          * @param b COMMENT
 122          * @return COMMENT
 123          */
 124         public static final <S, T, U> L1<S, U> compose(final L1<S, T> a, final L1<T, U> b) {
 125                 return new L1<S, U>() {
 126                         public S op(final U param) {
 127                                 return a.op(b.op(param));
 128                         }
 129                 };
 130         }
 131
 132         /**
 133          * @param <S> COMMENT
 134          * @param <T> COMMENT
 135          * @param map COMMENT
 136          * @param defaultValue COMMENT
 137          * @return COMMENT
 138          */
 139         public static final <S, T> L1<S, T> forMap(final Map<T, S> map, final S defaultValue) {
 140                 return new L1<S, T>() {
 141                         public S op(final T param) {
 142                                 if (map.containsKey(param))
 143                                         return map.get(param);
 144                                 return defaultValue;
 145                         }
 146                 };
 147         }
 148
 149         /**
 150          * @param <D> COMMENT
 151          * @param <K1> COMMENT
 152          * @param <K2> COMMENT
 153          * @param map COMMENT
 154          * @param defaultValue COMMENT
 155          * @return COMMENT
 156          */
 157         public static final <D, K1, K2> L2<D, K1, K2> forMap2(final DualMap<K1, K2, D> map, final D defaultValue) {
 158                 return new L2<D, K1, K2>() {
 159                         public D op(final K1 param1, final K2 param2) {
 160                                 return map.get(param1, param2);
 161                         }
 162                 };
 163         }
 164
 165         /**
 166          * @param <T> type
 167          * @return map which returns its argument
 168          */
 169         public static final <T> L1<T, T> identity() {
 170                 return new L1<T, T>() {
 171                         public T op(final T param) {
 172                                 return param;
 173                         }
 174                 };
 175         }
 176
 177         /**
 178          * returns the size of a collection
 179          */
 180         public static final L1<Integer, Collection<?>> COLLECTION_SIZE = new L1<Integer, Collection<?>>() {
 181                 public Integer op(final Collection<?> value) {
 182                         return value.size();
 183                 }
 184         };
 185         /**
 186          * returns the number of elements in the iterator (by iterating them, silly)
 187          */
 188         public static final L1<Integer, ? super Iterator<?>> ITERATOR_COUNT = new L1<Integer, Iterator<?>>() {
 189                 /**
 190                  * @see net.kezvh.functional.lambda.L1#op(java.lang.Object)
 191                  * @param arg0 some argument
 192                  * @return number of elements
 193                  */
 194                 @Override
 195                 public Integer op(final Iterator<?> arg0) {
 196                         int i;
 197                         for (i = 0; arg0.hasNext(); i++)
 198                                 arg0.next();
 199                         return i;
 200                 }
 201         };
 202         /**
 203          *
 204          */
 205         public static final L1<?, ?> UNSUPPORTED = new L1<?, ?>() {
 206                 public Object op(final Object param) {
 207                         throw new UnsupportedOperationException();
 208                 }
 209         };
 210         /**
 211          *
 212          */
 213         public static final L2<Integer, ? super Integer, ? super Integer> SUMI = new L2<Integer, Integer, Integer>() {
 214                 /**
 215                  * @see net.kezvh.functional.lambda.L2#op(java.lang.Object,
 216                  *      java.lang.Object)
 217                  * @param arg0 some argument
 218                  * @param arg1 some argument
 219                  * @return the sum of the arguments
 220                  */
 221                 @Override
 222                 public Integer op(final Integer arg0, final Integer arg1) {
 223                         return Integer.valueOf(arg0.intValue() + arg1.intValue());
 224                 }
 225         };
 226         /**
 227          *
 228          */
 229         public static final L1<Integer, Integer> INTEGER_INCREMENTER = new L1<Integer, Integer>() {
 230                 public Integer op(final Integer param) {
 231                         return param + 1;
 232                 }
 233         };
 234 }