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     */
017    package org.apache.logging.log4j.core.filter;
018    
019    import org.apache.logging.log4j.Level;
020    import org.apache.logging.log4j.Marker;
021    import org.apache.logging.log4j.core.AbstractLifeCycle;
022    import org.apache.logging.log4j.core.Filter;
023    import org.apache.logging.log4j.core.LogEvent;
024    import org.apache.logging.log4j.core.Logger;
025    import org.apache.logging.log4j.message.Message;
026    
027    /**
028     * Users should extend this class to implement filters. Filters can be either context wide or attached to
029     * an appender. A filter may choose to support being called only from the context or only from an appender in
030     * which case it will only implement the required method(s). The rest will default to return NEUTRAL.
031     *
032     */
033    public abstract class AbstractFilter extends AbstractLifeCycle implements Filter {
034        
035        private static final long serialVersionUID = 1L;
036    
037        /**
038         * The onMatch Result.
039         */
040        protected final Result onMatch;
041    
042        /**
043         * The onMismatch Result.
044         */
045        protected final Result onMismatch;
046    
047        /**
048         * The default constructor.
049         */
050        protected AbstractFilter() {
051            this(null, null);
052        }
053    
054        /**
055         * Constructor that allows the onMatch and onMismatch actions to be set.
056         * @param onMatch The result to return when a match occurs.
057         * @param onMismatch The result to return when a match dos not occur.
058         */
059        protected AbstractFilter(final Result onMatch, final Result onMismatch) {
060            this.onMatch = onMatch == null ? Result.NEUTRAL : onMatch;
061            this.onMismatch = onMismatch == null ? Result.DENY : onMismatch;
062        }
063    
064        @Override
065        public boolean equals(final Object obj) {
066            if (this == obj) {
067                return true;
068            }
069            if (!super.equals(obj)) {
070                return false;
071            }
072            if (getClass() != obj.getClass()) {
073                return false;
074            }
075            final AbstractFilter other = (AbstractFilter) obj;
076            if (onMatch != other.onMatch) {
077                return false;
078            }
079            if (onMismatch != other.onMismatch) {
080                return false;
081            }
082            return true;
083        }
084    
085        /**
086         * Context Filter method. The default returns NEUTRAL.
087         * @param event The LogEvent.
088         * @return The Result of filtering.
089         */
090        @Override
091        public Result filter(final LogEvent event) {
092            return Result.NEUTRAL;
093        }
094    
095        /**
096         * Appender Filter method. The default returns NEUTRAL.
097         * @param logger the Logger.
098         * @param level The logging Level.
099         * @param marker The Marker, if any.
100         * @param msg The message, if present.
101         * @param t A throwable or null.
102         * @return The Result of filtering.
103         */
104        @Override
105        public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg,
106                             final Throwable t) {
107            return Result.NEUTRAL;
108        }
109    
110        /**
111         * Appender Filter method. The default returns NEUTRAL.
112         * @param logger the Logger.
113         * @param level The logging Level.
114         * @param marker The Marker, if any.
115         * @param msg The message, if present.
116         * @param t A throwable or null.
117         * @return The Result of filtering.
118         */
119        @Override
120        public Result filter(final Logger logger, final Level level, final Marker marker, final Object msg,
121                             final Throwable t) {
122            return Result.NEUTRAL;
123        }
124    
125        /**
126         * Appender Filter method. The default returns NEUTRAL.
127         * @param logger the Logger.
128         * @param level The logging Level.
129         * @param marker The Marker, if any.
130         * @param msg The message, if present.
131         * @param params An array of parameters or null.
132         * @return The Result of filtering.
133         */
134        @Override
135        public Result filter(final Logger logger, final Level level, final Marker marker, final String msg,
136                             final Object... params) {
137            return Result.NEUTRAL;
138        }
139    
140        /**
141         * Returns the Result to be returned when a match occurs.
142         * @return the onMatch Result.
143         */
144        @Override
145        public final Result getOnMatch() {
146            return onMatch;
147        }
148    
149        /**
150         * Returns the Result to be returned when a match does not occur.
151         * @return the onMismatch Result.
152         */
153        @Override
154        public final Result getOnMismatch() {
155            return onMismatch;
156        }
157    
158        @Override
159        public int hashCode() {
160            final int prime = 31;
161            int result = super.hashCode();
162            result = prime * result + ((onMatch == null) ? 0 : onMatch.hashCode());
163            result = prime * result + ((onMismatch == null) ? 0 : onMismatch.hashCode());
164            return result;
165        }
166    
167        @Override
168        public String toString() {
169            return this.getClass().getSimpleName();
170        }
171    }