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

   1 package net.kezvh.functional.lambda;
   2
   3 import java.util.Map;
   4
   5 import net.kezvh.collections.Map2.Map2;
   6 import net.kezvh.lang.UtilityClass;
   7
   8 /**
   9  * @author afflux
  10  */
  11 public final class Operations extends UtilityClass {
  12         /**
  13          *
  14          */
  15         public static final Predicate2<?, ?> EQUALS = new Predicate2<Object, Object>() {
  16                 /**
  17                  * @see net.kezvh.functional.lambda.L2#op(java.lang.Object, java.lang.Object)
  18                  * @param param1 param1
  19                  * @param param2 param2
  20                  * @return x
  21                  */
  22                 @Override
  23                 public Boolean op(final Object param1, final Object param2) {
  24                         return (param1 == null) ? param2 == null : param1.equals(param2);
  25                 }
  26         };
  27
  28         /**
  29          * @param <T> COMMENT
  30          * @return COMMENT
  31          */
  32         @SuppressWarnings("unchecked")
  33         public static final <T> Predicate2<T, T> EQUALS() {
  34                 return (Predicate2<T, T>) Operations.EQUALS;
  35         }
  36
  37         /**
  38          * @param <T> COMMENT
  39          * @param t COMMENT
  40          * @return COMMENT
  41          */
  42         public static final <T> L0<T> CONSTANT(final T t) {
  43                 return new L0<T>() {
  44                         @Override
  45                         public T op() {
  46                                 return t;
  47                         }
  48                 };
  49         }
  50
  51         /**
  52          * @param <S> COMMENT
  53          * @param <T> COMMENT
  54          * @param s COMMENT
  55          * @return COMMENT
  56          */
  57         public static final <S, T> L1<S, T> CONSTANT(final S s) {
  58                 return new L1<S, T>() {
  59                         public S op(final T param) {
  60                                 return s;
  61                         }
  62                 };
  63         }
  64
  65         /**
  66          * @param <S> COMMENT
  67          * @param <T> COMMENT
  68          * @param <U> COMMENT
  69          * @param s COMMENT
  70          * @return COMMENT
  71          */
  72         public static final <S, T, U> L2<S, T, U> CONSTANT(final S s) {
  73                 return new L2<S, T, U>() {
  74                         public S op(final T param, final U param2) {
  75                                 return s;
  76                         }
  77                 };
  78         }
  79
  80         /**
  81          * @param <S> COMMENT
  82          * @param <T> COMMENT
  83          * @param <U> COMMENT
  84          * @param a COMMENT
  85          * @param b COMMENT
  86          * @return COMMENT
  87          */
  88         public static final <S, T, U> L1<S, U> compose(final L1<S, T> a, final L1<T, U> b) {
  89                 return new L1<S, U>() {
  90                         public S op(final U param) {
  91                                 return a.op(b.op(param));
  92                         }
  93                 };
  94         }
  95
  96         /**
  97          * @param <S> COMMENT
  98          * @param <T> COMMENT
  99          * @param map COMMENT
 100          * @param defaultValue COMMENT
 101          * @return COMMENT
 102          */
 103         public static final <S, T> L1<S, T> forMap(final Map<T, S> map, final S defaultValue) {
 104                 return new L1<S, T>() {
 105                         public S op(final T param) {
 106                                 if (map.containsKey(param))
 107                                         return map.get(param);
 108                                 return defaultValue;
 109                         }
 110                 };
 111         }
 112
 113         /**
 114          * @param <D> COMMENT
 115          * @param <K1> COMMENT
 116          * @param <K2> COMMENT
 117          * @param map COMMENT
 118          * @param defaultValue COMMENT
 119          * @return COMMENT
 120          */
 121         public static final <D, K1, K2> L2<D, K1, K2> forMap2(final Map2<K1, K2, D> map, final D defaultValue) {
 122                 return new L2<D, K1, K2>() {
 123                         public D op(final K1 param1, final K2 param2) {
 124                                 return map.get(param1, param2);
 125                         }
 126                 };
 127         }
 128
 129         /**
 130          * @param <T> type
 131          * @return map which returns its argument
 132          */
 133         public static final <T> L1<T, T> identity() {
 134                 return new L1<T, T>() {
 135                         public T op(final T param) {
 136                                 return param;
 137                         }
 138                 };
 139         }
 140 }