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        protected boolean equalsImpl(final Object obj) {
065            if (this == obj) {
066                return true;
067            }
068            if (!super.equalsImpl(obj)) {
069                return false;
070            }
071            if (getClass() != obj.getClass()) {
072                return false;
073            }
074            final AbstractFilter other = (AbstractFilter) obj;
075            if (onMatch != other.onMatch) {
076                return false;
077            }
078            if (onMismatch != other.onMismatch) {
079                return false;
080            }
081            return true;
082        }
083    
084        /**
085         * Context Filter method. The default returns NEUTRAL.
086         * @param event The LogEvent.
087         * @return The Result of filtering.
088         */
089        @Override
090        public Result filter(final LogEvent event) {
091            return Result.NEUTRAL;
092        }
093    
094        /**
095         * Appender Filter method. The default returns NEUTRAL.
096         * @param logger the Logger.
097         * @param level The logging Level.
098         * @param marker The Marker, if any.
099         * @param msg The message, if present.
100         * @param t A throwable or null.
101         * @return The Result of filtering.
102         */
103        @Override
104        public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg,
105                             final Throwable t) {
106            return Result.NEUTRAL;
107        }
108    
109        /**
110         * Appender Filter method. The default returns NEUTRAL.
111         * @param logger the Logger.
112         * @param level The logging Level.
113         * @param marker The Marker, if any.
114         * @param msg The message, if present.
115         * @param t A throwable or null.
116         * @return The Result of filtering.
117         */
118        @Override
119        public Result filter(final Logger logger, final Level level, final Marker marker, final Object msg,
120                             final Throwable t) {
121            return Result.NEUTRAL;
122        }
123    
124        /**
125         * Appender Filter method. The default returns NEUTRAL.
126         * @param logger the Logger.
127         * @param level The logging Level.
128         * @param marker The Marker, if any.
129         * @param msg The message, if present.
130         * @param params An array of parameters or null.
131         * @return The Result of filtering.
132         */
133        @Override
134        public Result filter(final Logger logger, final Level level, final Marker marker, final String msg,
135                             final Object... params) {
136            return Result.NEUTRAL;
137        }
138    
139        /**
140         * Returns the Result to be returned when a match occurs.
141         * @return the onMatch Result.
142         */
143        @Override
144        public final Result getOnMatch() {
145            return onMatch;
146        }
147    
148        /**
149         * Returns the Result to be returned when a match does not occur.
150         * @return the onMismatch Result.
151         */
152        @Override
153        public final Result getOnMismatch() {
154            return onMismatch;
155        }
156    
157        protected int hashCodeImpl() {
158            final int prime = 31;
159            int result = super.hashCodeImpl();
160            result = prime * result + ((onMatch == null) ? 0 : onMatch.hashCode());
161            result = prime * result + ((onMismatch == null) ? 0 : onMismatch.hashCode());
162            return result;
163        }
164    
165        @Override
166        public String toString() {
167            return this.getClass().getSimpleName();
168        }
169    }