Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jboss.weld.metadata;
  
 
A predicate which selects classes to process based on a filter.

This filter will determine if the filter is active on instantiation, so should only be instantiated when it is ready to be used.

Author(s):
Pete Muir
 
 public class FilterPredicate implements Predicate<String> {
 
     private final boolean active;
     private final Matcher matcher;
 
     public FilterPredicate(Metadata<FilterfilterResourceLoader resourceLoader) {
         boolean active = true;
         if (filter.getValue().getClassAvailableActivations() != null) {
             for (Metadata<ClassAvailableActivationclassAvailableActivation : filter.getValue().getClassAvailableActivations()) {
                 if (classAvailableActivation.getValue() == null) {
                     throw new IllegalStateException("Class available activation metadata not available at " + classAvailableActivation);
                 }
                 String className = classAvailableActivation.getValue().getClassName();
                 if (className == null) {
                     throw new IllegalStateException("Must specify class name at " + classAvailableActivation);
                 }
                 boolean inverted = isInverted(className) || classAvailableActivation.getValue().isInverted();
                 if (inverted) {
                     className = removeInversion(className);
                 }
                 active = active && isClassAvailable(classNameresourceLoaderinverted);
             }
         }
         if (filter.getValue().getSystemPropertyActivations() != null) {
             for (Metadata<SystemPropertyActivationsystemPropertyActivation : filter.getValue().getSystemPropertyActivations()) {
                 if (systemPropertyActivation.getValue() == null) {
                     throw new IllegalStateException("System property activation metadata not available at " + systemPropertyActivation);
                 }
                 String propertyName = systemPropertyActivation.getValue().getName();
                 String requiredPropertyValue = systemPropertyActivation.getValue().getValue();
                 if (propertyName == null) {
                     throw new IllegalStateException("Must specify system property name at " + systemPropertyActivation);
                 }
                 boolean propertyNameInverted = isInverted(propertyName);
 
                 if (propertyNameInverted && requiredPropertyValue != null) {
                     throw new IllegalStateException("Cannot invert property name and specify property value at " + systemPropertyActivation);
                 }
 
                 if (propertyNameInverted) {
                     propertyName = removeInversion(propertyName);
                 }
 
                 String actualPropertyValue = AccessController.doPrivileged(new GetSystemPropertyAction(propertyName));
                 if (requiredPropertyValue == null) {
                     active = active && isNotNull(actualPropertyValuepropertyNameInverted);
                 } else {
                     boolean requiredPropertyValueInverted = isInverted(requiredPropertyValue);
                     if (requiredPropertyValueInverted) {
                         requiredPropertyValue = removeInversion(requiredPropertyValue);
                     }
                     active = active && isEqual(requiredPropertyValueactualPropertyValuerequiredPropertyValueInverted);
                 }
             }
         }
         this. = active;
         if (filter.getValue() instanceof WeldFilter) {
             WeldFilter weldFilter = (WeldFilterfilter.getValue();
             if ((weldFilter.getName() != null && weldFilter.getPattern() != null)
              || (weldFilter.getName() == null && weldFilter.getPattern() == null)) {
                 throw new IllegalStateException("Cannot specify both a pattern and a name at " + filter);
             }
             if (weldFilter.getPattern() != null) {
                 this. = new PatternMatcher(filterweldFilter.getPattern());
             } else {
                 this. = new AntSelectorMatcher(weldFilter.getName());
             }
         } else {
             if (filter.getValue().getName() == null) {
                 throw new IllegalStateException("Name must be specified at " + filter);
             }
             String name = filter.getValue().getName();
             String suffixDotDoubleStar = ".**";
             String suffixDotStar = ".*";
             if (name.endsWith(suffixDotDoubleStar)) {
                this. = new PrefixMatcher(name.substring(0, name.length() - suffixDotDoubleStar.length()), filter);
            } else if (name.endsWith(suffixDotStar)) {
                this. = new PackageMatcher(name.substring(0, name.length() - suffixDotStar.length()), filter);
            } else {
                this. = new FullyQualifierClassNameMatcher(namefilter);
            }
        }
    }
    public boolean apply(String className) {
        if () {
            return .matches(className);
        } else {
            return false;
        }
    }
    private static boolean isClassAvailable(String classNameResourceLoader resourceLoaderboolean invert) {
        if (invert) {
            return !isClassAvailable(classNameresourceLoader);
        } else {
            return isClassAvailable(classNameresourceLoader);
        }
    }
    private static boolean isClassAvailable(String classNameResourceLoader resourceLoader) {
        try {
            resourceLoader.classForName(className);
        } catch (ResourceLoadingException e) {
            return false;
        }
        return true;
    }
    private static boolean isNotNull(String stringboolean invert) {
        if (invert) {
            return string == null;
        } else {
            return string != null;
        }
    }
    private static boolean isEqual(String string1String string2boolean invert) {
        if (invert) {
            return !string1.equals(string2);
        } else {
            return string1.equals(string2);
        }
    }
    private static boolean isInverted(String string) {
        return string.startsWith("!");
    }
    private static String removeInversion(String string) {
        if (!string.startsWith("!")) {
            return string;
        }
        return string.substring(1);
    }
    private interface Matcher {
        boolean matches(String input);
    }
    private static class PatternMatcher implements Matcher {
        private final Pattern pattern;
        private PatternMatcher(Metadata<FilterfilterString pattern) {
            try {
                this. = Pattern.compile(pattern);
            } catch (PatternSyntaxException e) {
                throw new IllegalStateException("Error parsing pattern at " + filtere);
            }
        }
        @Override
        public boolean matches(String input) {
            return .matcher(input).matches();
        }
    }
    private static class AntSelectorMatcher implements Matcher {
        private final String name;
        private AntSelectorMatcher(String name) {
            this. = name;
        }
        @Override
        public boolean matches(String input) {
            return Selectors.matchPath(this.input);
        }
    }
    private abstract static class CDI11Matcher implements Matcher {
        private static final Pattern CDI11_EXCLUDE_PATTERN = Pattern.compile("([\\p{L}_$][\\p{L}\\p{N}_$]*\\.)*[\\p{L}_$][\\p{L}\\p{N}_$]*");
        protected final String expression;
        private CDI11Matcher(String expressionMetadata<Filterfilter) {
            this. = expression;
            if (!.matcher(expression).matches()) {
                throw new IllegalArgumentException("Invalid expression " + filter);
            }
        }
    }
    private static class FullyQualifierClassNameMatcher extends CDI11Matcher {
        private FullyQualifierClassNameMatcher(String fqcnMetadata<Filterfilter) {
            super(fqcnfilter);
        }
        @Override
        public boolean matches(String input) {
            return .equals(input);
        }
    }
    private static class PrefixMatcher extends CDI11Matcher {
        private PrefixMatcher(String prefixMetadata<Filterfilter) {
            super(prefixfilter);
        }
        @Override
        public boolean matches(String input) {
            return input != null && input.startsWith();
        }
    }
    private static class PackageMatcher extends CDI11Matcher {
        private PackageMatcher(String pkgMetadata<Filterfilter) {
            super(pkgfilter);
        }
        @Override
        public boolean matches(String input) {
            if (input == null) {
                return false;
            }
            int lastDot = input.lastIndexOf('.');
            if (lastDot == -1) {
                return false;
            }
            return .equals(input.substring(0, lastDot));
        }
    }
New to GrepCode? Check out our FAQ X