001/**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.camel.util.jsse;
018
019import java.util.ArrayList;
020import java.util.Arrays;
021import java.util.Collections;
022import java.util.List;
023import java.util.regex.Pattern;
024import java.util.regex.PatternSyntaxException;
025
026/**
027 * Represents a set of regular expression based filter patterns for
028 * including and excluding content of some type.
029 */
030public class FilterParameters extends JsseParameters {
031
032    protected List<String> include;
033    protected List<String> exclude;
034
035    /**
036     * Returns a live copy of the list of patterns to include.
037     * The list of excludes takes precedence over the include patterns.
038     *
039     * @return the list of patterns to include
040     */
041    public List<String> getInclude() {
042        if (this.include == null) {
043            this.include = new ArrayList<>();
044        }
045        return this.include;
046    }
047
048    /**
049     * Returns a live copy of the list of patterns to exclude.
050     * This list takes precedence over the include patterns.
051     *
052     * @return the list of patterns to exclude
053     */
054    public List<String> getExclude() {
055        if (exclude == null) {
056            exclude = new ArrayList<>();
057        }
058        return this.exclude;
059    }
060    
061    /**
062     * Returns a list of compiled {@code Pattern}s based on the
063     * values of the include list.
064     *
065     * @return the list of compiled expressions, never {@code null}
066     *
067     * @throws PatternSyntaxException if any of the expressions are invalid
068     */
069    public List<Pattern> getIncludePatterns() {
070        return this.getPattern(this.getInclude());
071    }
072    
073    /**
074     * Returns a list of compiled {@code Pattern}s based on the
075     * values of the exclude list.
076     *
077     * @return the list of compiled expressions, never {@code null}
078     * 
079     * @throws PatternSyntaxException if any of the expressions are invalid
080     */
081    public List<Pattern> getExcludePatterns() {
082        return this.getPattern(this.getExclude());
083    }
084    
085    /**
086     * Returns an immutable collection of compiled filter patterns based on
087     * the state of this instance at the time of invocation.
088     */
089    public Patterns getPatterns() {
090        return new Patterns(this.getIncludePatterns(), this.getExcludePatterns());
091    }
092    
093    /**
094     * Compiles {@code Pattern}s for each expression in {@code patternStrings}.
095     *
096     * @param patternStrings the list of regular expressions to compile
097     *
098     * @return the list of compiled patterns
099     *
100     * @throws PatternSyntaxException if any of the expressions are invalid
101     */
102    protected List<Pattern> getPattern(List<String> patternStrings) {
103        List<Pattern> patterns = new ArrayList<>(patternStrings.size());
104        
105        for (String expression : patternStrings) {
106            patterns.add(Pattern.compile(this.parsePropertyValue(expression)));
107        }
108        return patterns;
109    }
110    
111    /**
112     * An immutable collection of compiled includes and excludes filter {@link Pattern}s.
113     */
114    public static class Patterns {
115        private final List<Pattern> includes;
116        private final List<Pattern> excludes;
117        
118        public Patterns(List<Pattern> includes, List<Pattern> excludes) {
119            this.includes = Collections.unmodifiableList(new ArrayList<>(includes));
120            this.excludes = Collections.unmodifiableList(new ArrayList<>(excludes));
121        }
122
123        public List<Pattern> getIncludes() {
124            return includes;
125        }
126
127        public List<Pattern> getExcludes() {
128            return excludes;
129        }
130
131        @Override
132        public String toString() {
133            StringBuilder builder = new StringBuilder();
134            builder.append("Patterns [includes=");
135            builder.append(includes);
136            builder.append(", excludes=");
137            builder.append(excludes);
138            builder.append("]");
139            return builder.toString();
140        }
141    }
142
143    @Override
144    public String toString() {
145        StringBuilder builder = new StringBuilder();
146        builder.append("FilterParameters[include=");
147        builder.append(Arrays.toString(getInclude().toArray(new String[getInclude().size()])));
148        builder.append(", exclude=");
149        builder.append(Arrays.toString(getExclude().toArray(new String[getExclude().size()])));
150        builder.append("]");
151        return builder.toString();
152    }
153}