Java Code Examples for org.jboss.modules.filter.PathFilters#multiplePathFilterBuilder()

private void addResourceRoot(final ModuleSpec.Builder specBuilder, final ResourceRoot resource, final List<PermissionFactory> permFactories)
        throws DeploymentUnitProcessingException {
    try {
        final VirtualFile root = resource.getRoot();
        if (resource.getExportFilters().isEmpty()) {
            specBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(new VFSResourceLoader(resource
                    .getRootName(), root, resource.isUsePhysicalCodeSource())));
        } else {
            final MultiplePathFilterBuilder filterBuilder = PathFilters.multiplePathFilterBuilder(true);
            for (final FilterSpecification filter : resource.getExportFilters()) {
                filterBuilder.addFilter(filter.getPathFilter(), filter.isInclude());
            }
            specBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(new VFSResourceLoader(resource
                    .getRootName(), root, resource.isUsePhysicalCodeSource()), filterBuilder.create()));
        }
        // start with the root
        permFactories.add(new ImmediatePermissionFactory(
                new VirtualFilePermission(root.getPathName(), VirtualFilePermission.FLAG_READ)));
        // also include all children, recursively
        permFactories.add(new ImmediatePermissionFactory(
                new VirtualFilePermission(root.getChild("-").getPathName(), VirtualFilePermission.FLAG_READ)));
    } catch (IOException e) {
        throw ServerLogger.ROOT_LOGGER.failedToCreateVFSResourceLoader(resource.getRootName(), e);
    }
}
 

/**
 * Build a PathFilter for a set of filter paths
 *
 * @param filterPaths the set of paths to filter on.
 *        Can be null to indicate that no filters should be applied (accept all),
 *        can be empty to indicate that everything should be filtered (reject all).
 * @param failedMatchValue the value the PathFilter returns when a path does not match.
 * @return a PathFilter.
 */
private static PathFilter buildFilters(Set<String> filterPaths, boolean failedMatchValue) {
    if (filterPaths == null)
        return PathFilters.acceptAll();
    else if (filterPaths.isEmpty()) {
        return PathFilters.rejectAll();
    } else {
        MultiplePathFilterBuilder builder = PathFilters.multiplePathFilterBuilder(failedMatchValue);
        for (String importPathGlob : filterPaths)
            builder.addFilter(PathFilters.match(importPathGlob), !failedMatchValue);
        return builder.create();
    }
}
 

private static void parseSystemDependency(final XMLStreamReader reader, final ModuleStructureSpec specBuilder) throws XMLStreamException {
    boolean export = false;
    final int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        final Attribute attribute = Attribute.of(reader.getAttributeName(i));
        switch (attribute) {
            case EXPORT:
                export = Boolean.parseBoolean(reader.getAttributeValue(i));
                break;
            default:
                throw unexpectedContent(reader);
        }
    }
    Set<String> paths = Collections.emptySet();
    final MultiplePathFilterBuilder exportBuilder = PathFilters.multiplePathFilterBuilder(export);
    while (reader.hasNext()) {
        switch (reader.nextTag()) {
            case END_ELEMENT: {
                if (export) {
                    // If re-exported, add META-INF/** -> false at the end of the list (require explicit override)
                    exportBuilder.addFilter(PathFilters.getMetaInfSubdirectoriesFilter(), false);
                    exportBuilder.addFilter(PathFilters.getMetaInfFilter(), false);
                }
                final PathFilter exportFilter = exportBuilder.create();
                specBuilder.addSystemDependency(DependencySpec.createSystemDependencySpec(PathFilters.getDefaultImportFilter(), exportFilter, paths));
                return;
            }
            case START_ELEMENT: {
                switch (Element.of(reader.getName())) {
                    case PATHS: {
                        paths = parseSet(reader);
                        break;
                    }
                    case EXPORTS: {
                        parseFilterList(reader, exportBuilder);
                        break;
                    }
                    default: {
                        throw unexpectedContent(reader);
                    }
                }
            }
        }
    }
}
 

private static void parseSystemDependency(final XMLStreamReader reader, final ModuleStructureSpec specBuilder) throws XMLStreamException {
    boolean export = false;
    final int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        final Attribute attribute = Attribute.of(reader.getAttributeName(i));
        switch (attribute) {
            case EXPORT:
                export = Boolean.parseBoolean(reader.getAttributeValue(i));
                break;
            default:
                throw unexpectedContent(reader);
        }
    }
    Set<String> paths = Collections.emptySet();
    final MultiplePathFilterBuilder exportBuilder = PathFilters.multiplePathFilterBuilder(export);
    while (reader.hasNext()) {
        switch (reader.nextTag()) {
            case END_ELEMENT: {
                if (export) {
                    // If re-exported, add META-INF/** -> false at the end of the list (require explicit override)
                    exportBuilder.addFilter(PathFilters.getMetaInfSubdirectoriesFilter(), false);
                    exportBuilder.addFilter(PathFilters.getMetaInfFilter(), false);
                }
                final PathFilter exportFilter = exportBuilder.create();
                specBuilder.addSystemDependency(DependencySpec.createSystemDependencySpec(PathFilters.getDefaultImportFilter(), exportFilter, paths));
                return;
            }
            case START_ELEMENT: {
                switch (Element.of(reader.getName())) {
                    case PATHS: {
                        paths = parseSet(reader);
                        break;
                    }
                    case EXPORTS: {
                        parseFilterList(reader, exportBuilder);
                        break;
                    }
                    default: {
                        throw unexpectedContent(reader);
                    }
                }
            }
        }
    }
}
 

private static void parseSystemDependency(final XMLStreamReader reader, final ModuleStructureSpec specBuilder) throws XMLStreamException {
    boolean export = false;
    final int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        final Attribute attribute = Attribute.of(reader.getAttributeName(i));
        switch (attribute) {
            case EXPORT:
                export = Boolean.parseBoolean(reader.getAttributeValue(i));
                break;
            default:
                throw unexpectedContent(reader);
        }
    }
    Set<String> paths = Collections.emptySet();
    final MultiplePathFilterBuilder exportBuilder = PathFilters.multiplePathFilterBuilder(export);
    while (reader.hasNext()) {
        switch (reader.nextTag()) {
            case END_ELEMENT: {
                if (export) {
                    // If re-exported, add META-INF/** -> false at the end of the list (require explicit override)
                    exportBuilder.addFilter(PathFilters.getMetaInfSubdirectoriesFilter(), false);
                    exportBuilder.addFilter(PathFilters.getMetaInfFilter(), false);
                }
                final PathFilter exportFilter = exportBuilder.create();
                specBuilder.addSystemDependency(DependencySpec.createSystemDependencySpec(PathFilters.getDefaultImportFilter(), exportFilter, paths));
                return;
            }
            case START_ELEMENT: {
                switch (Element.of(reader.getName())) {
                    case PATHS: {
                        paths = parseSet(reader);
                        break;
                    }
                    case EXPORTS: {
                        parseFilterList(reader, exportBuilder);
                        break;
                    }
                    default: {
                        throw unexpectedContent(reader);
                    }
                }
            }
        }
    }
}