import io.undertow.predicate.Predicate; //导入依赖的package包/类
public void addTo(RoutingHandler rh, OptionMap config) {
	List<Predicate> list = new ArrayList<>();
	list.add(this.predicate);
	list.add(this.matches);
	Route route = this.route;
	if (this.type != null && this.type.isEmpty() == false) {
		list.add(MIMEPredicate.accept(type));
		route = (req, res) -> {
			Object result = this.route.handle(req, res);
			res.type(this.type);
			return result;
		};
	}
	this.accepts.stream().filter(s -> s.isEmpty() == false)
			.map(s -> MIMEPredicate.contentType(s)).forEach(list::add);
	rh.add(Predicates.and(list.toArray(new Predicate[list.size()])), route,
			this.renderer);
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
public String readAttribute(final HttpServerExchange exchange) {
    Map<String, Object> context = exchange.getAttachment(Predicate.PREDICATE_CONTEXT);
    if (context != null) {
        Object object = context.get(name);
        return object == null ? null : object.toString();
    }
    return null;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
public void writeAttribute(final HttpServerExchange exchange, final String newValue) throws ReadOnlyAttributeException {
    Map<String, Object> context = exchange.getAttachment(Predicate.PREDICATE_CONTEXT);
    if (context != null) {
        context.put(name, newValue);
    }
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public ContentEncodedResourceManager(File encodedResourcesRoot, CachingResourceManager encodedResourceManager, ContentEncodingRepository contentEncodingRepository, int minResourceSize, int maxResourceSize, Predicate encodingAllowed) {
    this.encodedResourcesRoot = encodedResourcesRoot;
    this.encoded = encodedResourceManager;
    this.contentEncodingRepository = contentEncodingRepository;
    this.minResourceSize = minResourceSize;
    this.maxResourceSize = maxResourceSize;
    this.encodingAllowed = encodingAllowed;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public static List<PredicatedHandler> parse(final String contents, final ClassLoader classLoader) {
    String[] lines = contents.split("\\n");
    final List<PredicatedHandler> wrappers = new ArrayList<>();

    for (String line : lines) {
        if (line.trim().length() > 0) {
            Predicate predicate;
            HandlerWrapper handler;
            String[] parts = line.split("->");
            if (parts.length == 2) {
                predicate = PredicateParser.parse(parts[0], classLoader);
                handler = HandlerParser.parse(parts[1], classLoader);
            } else if (parts.length == 1) {
                predicate = Predicates.truePredicate();
                handler = HandlerParser.parse(parts[0], classLoader);
            } else {
                predicate = PredicateParser.parse(parts[0], classLoader);
                HandlerWrapper[] handlers = new HandlerWrapper[parts.length -1];
                for(int i = 0; i < handlers.length; ++i) {
                    handlers[i] = HandlerParser.parse(parts[i + 1], classLoader);
                }
                handler = new ChaninedHandlerWrapper(Arrays.asList(handlers));
            }
            wrappers.add(new PredicatedHandler(predicate, handler));
        }
    }
    return wrappers;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public synchronized RoutingHandler add(HttpString method, String template, Predicate predicate, HttpHandler handler) {
    PathTemplateMatcher<RoutingMatch> matcher = matches.get(method);
    if (matcher == null) {
        matches.put(method, matcher = new PathTemplateMatcher<>());
    }
    RoutingMatch res = matcher.get(template);
    if (res == null) {
        matcher.add(template, res = new RoutingMatch());
    }
    if (allMethodsMatcher.get(template) == null) {
        allMethodsMatcher.add(template, res);
    }
    res.predicatedHandlers.add(new HandlerHolder(predicate, handler));
    return this;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
private Predicate[] getCompressionPredicates(Compression compression) {
	List<Predicate> predicates = new ArrayList<Predicate>();
	predicates.add(new MaxSizePredicate(compression.getMinResponseSize()));
	predicates.add(new CompressibleMimeTypePredicate(compression.getMimeTypes()));
	if (compression.getExcludedUserAgents() != null) {
		for (String agent : compression.getExcludedUserAgents()) {
			RequestHeaderAttribute agentHeader = new RequestHeaderAttribute(
					new HttpString(HttpHeaders.USER_AGENT));
			predicates.add(Predicates.not(Predicates.regex(agentHeader, agent)));
		}
	}
	return predicates.toArray(new Predicate[predicates.size()]);
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
private Predicate[] getCompressionPredicates(Compression compression) {
	List<Predicate> predicates = new ArrayList<Predicate>();
	predicates.add(Predicates.maxContentSize(compression.getMinResponseSize()));
	predicates.add(new CompressibleMimeTypePredicate(compression.getMimeTypes()));
	if (compression.getExcludedUserAgents() != null) {
		for (String agent : compression.getExcludedUserAgents()) {
			RequestHeaderAttribute agentHeader = new RequestHeaderAttribute(
					new HttpString(HttpHeaders.USER_AGENT));
			predicates.add(Predicates.not(Predicates.regex(agentHeader, agent)));
		}
	}
	return predicates.toArray(new Predicate[predicates.size()]);
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
public void addPredicate(int priority, Predicate predicate, HttpHandler truePredicate) {
  if(priority < 0) {
    throw new IllegalStateException("The priority must be > 0");
  }

  conditionalHandlers.push(new ConditionalHandlerHolder(priority, predicate, truePredicate));
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public synchronized RoutingHandler add(HttpString method, String template, Predicate predicate, HttpHandler handler) {
  CustomPathTemplateMatcher<RoutingMatch> matcher = matches.get(method);
  if (matcher == null) {
    matches.put(method, matcher = new CustomPathTemplateMatcher<>());
  }
  RoutingMatch res = matcher.get(template);
  if (res == null) {
    matcher.add(template, res = new RoutingMatch());
  }
  if (allMethodsMatcher.get(template) == null) {
    allMethodsMatcher.add(template, res);
  }
  res.predicatedHandlers.add(new HandlerHolder(predicate, handler));
  return this;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public WebSocketDef(String template, Predicate predicate,
		WebSocketFactory factory) {
	super();
	this.template = template;
	this.predicate = predicate;
	this.factory = factory;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public RoutingDef(String template, Predicate predicate, HttpMethod method,
		Route route) {
	this.template = template;
	this.predicate = predicate;
	this.method = method;
	this.route = route;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
Consumer<? super Map<String, Object>> consumeConfiguration() {
    return u -> {
        Object _role = u.get("role");
        Object _predicate = u.get("predicate");

        if (_role == null || !(_role instanceof String)) {
            throw new IllegalArgumentException("wrong configuration file format. a permission entry is missing the role");
        }

        String role = (String) _role;

        if (_predicate == null || !(_predicate instanceof String)) {
            throw new IllegalArgumentException("wrong configuration file format. a permission entry is missing the predicate");
        }

        Predicate predicate = null;

        try {
            predicate = PredicateParser.parse((String) _predicate, this.getClass().getClassLoader());
        } catch (Throwable t) {
            throw new IllegalArgumentException("wrong configuration file format. wrong predicate " + _predicate, t);
        }

        aclForRole(role).add(predicate);
    };
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
public boolean isAuthenticationRequired(final HttpServerExchange exchange) {
    if (getAcl() == null) {
        return true;
    }

    Set<Predicate> ps = getAcl().get("$unauthenticated");
    return ps == null ? true : !ps.stream().anyMatch(p -> p.resolve(exchange));
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
private Set<Predicate> aclForRole(String role) {
    Set<Predicate> predicates = getAcl().get(role);
    if (predicates == null) {
        predicates = newHashSet();
        getAcl().put(role, predicates);
    }

    return predicates;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
protected HttpHandler wrapWithStaticHandler(HttpHandler baseHandler, String path) {
    // static path is given relative to application root
    if (!new File(path).isAbsolute()) {
        path = WunderBoss.options().get("root", "").toString() + File.separator + path;
    }
    if (!new File(path).exists()) {
        log.debug("Not adding static handler for nonexistent directory {}", path);
        return baseHandler;
    }
    log.debug("Adding static handler for {}", path);
    final ResourceManager resourceManager =
            new CachingResourceManager(1000, 1L, null,
                                       new FileResourceManager(new File(path), 1 * 1024 * 1024), 250);
    String[] welcomeFiles = new String[] { "index.html", "index.html", "default.html", "default.htm" };
    final List<String> welcomeFileList = new CopyOnWriteArrayList<>(welcomeFiles);
    final ResourceHandler resourceHandler = new ResourceHandler()
            .setResourceManager(resourceManager)
            .setWelcomeFiles(welcomeFiles)
            .setDirectoryListingEnabled(false);

    return new PredicateHandler(new Predicate() {
            @Override
            public boolean resolve(HttpServerExchange value) {
                try {
                    Resource resource = resourceManager.getResource(value.getRelativePath());
                    if (resource == null) {
                        return false;
                    }
                    if (resource.isDirectory()) {
                        Resource indexResource = getIndexFiles(resourceManager, resource.getPath(), welcomeFileList);
                        return indexResource != null;
                    }
                    return true;
                } catch (IOException ex) {
                    return false;
                }
            }
    }, resourceHandler, baseHandler);
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
@Override
public Predicate build(final Map<String, Object> config) {
    String value = (String) config.get("value");
    return new DispatcherTypePredicate(DispatcherType.valueOf(value));
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public HttpContinueAcceptingHandler(HttpHandler next, Predicate accept) {
    this.next = next;
    this.accept = accept;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public Predicate getCachable() {
    return cachable;
}
 

import io.undertow.predicate.Predicate; //导入依赖的package包/类
public ResourceHandler setCachable(final Predicate cachable) {
    this.cachable = cachable;
    return this;
}