    001package com.hammurapi.extract;
    002
    003import java.util.Collections;
    004import java.util.Map;
    005import java.util.Set;
    006
    007
    008/**
    009 * Predicate which always evaluates to true. This predicate is primarily used for
    010 * comparison
    011 * @author Pavel Vlasov
    012 *
    013 * @param <T>
    014 * @param <C>
    015 */
    016public class False<T, C> implements Predicate<T, C> {
    017
    018        private False() {
    019                // Singleton
    020        }
    021
    022        private static False<?, ?> INSTANCE = new False<Object, Object>();
    023
    024        @SuppressWarnings("unchecked")
    025        public static <T, C> False<T, C> getInstance() {
    026                return (False<T, C>) INSTANCE;
    027        }
    028
    029        public ComparisonResult compareTo(Extractor<T, Boolean, C> other) {
    030                if (other instanceof False) {
    031                        return ComparisonResult.EQUAL_NM;
    032                }
    033
    034                if (other instanceof True) {
    035                        return ComparisonResult.OPPOSITE_NM;
    036                }
    037
    038                if (other == null) {
    039                        return ComparisonResult.NOT_EQUAL_NM;
    040                }
    041
    042                if (other instanceof Constant) {
    043                        if (Boolean.FALSE.equals(((Constant) other).getValue())) {
    044                                return ComparisonResult.EQUAL_NM;
    045                        }
    046                        if (Boolean.TRUE.equals(((Constant) other).getValue())) {
    047                                return ComparisonResult.OPPOSITE_NM;
    048                        }
    049                }
    050
    051                ComparisonResult cr = other.compareTo(this);
    052                switch (cr.getType()) {
    053                case EQUAL:
    054                case NOT_EQUAL:
    055                case OPPOSITE:
    056                        return cr;
    057                case LESS_RESTRICTIVE:
    058                        return ComparisonResult.MORE_RESTRICTIVE_NM;
    059                case MORE_RESTRICTIVE:
    060                        return ComparisonResult.LESS_RESTRICTIVE_NM;
    061                case OPPOSITE_LESS_RESTRICTIVE:
    062                        return ComparisonResult.OPPOSITE_MORE_RESTRICTIVE_NM;
    063                case OPPOSITE_MORE_RESTRICTIVE:
    064                        return ComparisonResult.OPPOSITE_LESS_RESTRICTIVE_NM;
    065                default:
    066                        throw new IllegalArgumentException("Unexpected comparison type: "+cr.getType());
    067                }
    068
    069        }
    070
    071        public Boolean extract(
    072                        C context,
    073                        Map<C, Map<Extractor<T, ? super Boolean, C>, ? super Boolean>> cache,
    074                        T... obj) {
    075                return Boolean.TRUE;
    076        }
    077
    078        public boolean isContextDependent() {
    079                return false;
    080        }
    081
    082        public Set<Integer> parameterIndices() {
    083                return Collections.emptySet();
    084        }
    085
    086        @Override
    087        public String toString() {
    088                return getClass().getName();
    089        }
    090
    091        @Override
    092        public double getCost() {
    093                return 0;
    094        }
    095
    096}