public void filter(ContainerRequestContext requestContext) throws IOException {
    Request request = (Request)this._requestProvider.get();
    Method endpointMethod = this._resourceInfo.getResourceMethod();
    AccessControl accessControl = this._accessControlFactory.create();
    String endpointUrl = request.getRequestURI().substring(request.getContextPath().length());
    UriInfo uriInfo = requestContext.getUriInfo();
    if (!isBaseFile(uriInfo.getPath()) && !UNPROTECTED_PATHS.contains(uriInfo.getPath())) {
        if (!accessControl.protectAnnotatedOnly() || endpointMethod.isAnnotationPresent(Authenticate.class)) {
            if (!endpointMethod.isAnnotationPresent(ManualAuthorization.class)) {
                String tableName = extractTableName(uriInfo.getPathParameters(), uriInfo.getQueryParameters());
                if (tableName != null) {
                    tableName = DatabaseUtils.translateTableName(tableName, this._httpHeaders);
                }

                AccessType accessType = this.extractAccessType(endpointMethod);
                AccessControlUtils.validatePermission(tableName, accessType, this._httpHeaders, endpointUrl, accessControl);
                FineGrainedAuthUtils.validateFineGrainedAuth(endpointMethod, uriInfo, this._httpHeaders, accessControl);
            }
        }
    }
}

public Stage.Continuation<RequestProcessingContext> apply(RequestProcessingContext context) {
    ContainerRequest request = context.request();
    context.triggerEvent(Type.MATCHING_START);
    TracingLogger tracingLogger = TracingLogger.getInstance(request);
    long timestamp = tracingLogger.timestamp(ServerTraceEvent.MATCH_SUMMARY);

    Stage.Continuation var8;
    try {
        RoutingResult result = this._apply(context, this.routingRoot);
        Stage<RequestProcessingContext> nextStage = null;
        if (result.endpoint != null) {
            context.routingContext().setEndpoint(result.endpoint);
            nextStage = this.getDefaultNext();
        }

        var8 = Continuation.of(result.context, nextStage);
    } finally {
        tracingLogger.logDuration(ServerTraceEvent.MATCH_SUMMARY, timestamp, new Object[0]);
    }

    return var8;
}

public Router.Continuation apply(RequestProcessingContext processingContext) {
    RoutingContext rc = processingContext.routingContext();
    rc.pushMatchResult(new SingleMatchResult("/" + processingContext.request().getPath(false)));
    return Continuation.of(processingContext, this.rootRouter);
}

public SingleMatchResult(String path) {
    this.path = stripMatrixParams(path);
}

private static String stripMatrixParams(String path) {
    int e = path.indexOf(59);
    if (e == -1) {
        return path;
    } else {
        int s = 0;
        StringBuilder sb = new StringBuilder();

        do {
            sb.append(path, s, e);
            s = path.indexOf(47, e + 1);
            if (s == -1) {
                break;
            }

            e = path.indexOf(59, s);
        } while(e != -1);

        if (s != -1) {
            sb.append(path, s, path.length());
        }

        return sb.toString();
    }
}