/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package jakarta.servlet.http;

import java.io.IOException;

import jakarta.servlet.FilterChain;
import jakarta.servlet.GenericFilter;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

Provides a base class that implements the Filter interface and ensures
that the Request and Response are of type HttpServletRequest and
HttpServletResponse respectively.
/**
 * Provides a base class that implements the Filter interface and ensures
 * that the Request and Response are of type HttpServletRequest and
 * HttpServletResponse respectively.
 */
public abstract class HttpFilter extends GenericFilter {

    private static final long serialVersionUID = 1L;

    
{@inheritDoc} This implementation tests the request and response to see if they are instances of HttpServletRequest and HttpServletResponse respectively. If they are then they are passed to doFilter(HttpServletRequest, HttpServletResponse, FilterChain). If not, a ServletException is thrown. 
Throws:
ServletException – If either the request or response are not of the
        expected types or any other error occurs/**
     * {@inheritDoc}
     *
     * This implementation tests the request and response to see if they are
     * instances of {@link HttpServletRequest} and {@link HttpServletResponse}
     * respectively. If they are then they are passed to
     * {@link #doFilter(HttpServletRequest, HttpServletResponse, FilterChain)}.
     * If not, a {@link ServletException} is thrown.
     *
     * @throws ServletException If either the request or response are not of the
     *         expected types or any other error occurs
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (!(request instanceof HttpServletRequest)) {
            throw new ServletException(request + " not HttpServletRequest");
        }
        if (!(response instanceof HttpServletResponse)) {
            throw new ServletException(request + " not HttpServletResponse");
        }
        doFilter((HttpServletRequest) request, (HttpServletResponse) response, chain);
    }


    
The doFilter method of the Filter is called by the container
each time a request/response pair is passed through the chain due to a
client request for a resource at the end of the chain. The FilterChain
passed in to this method allows the Filter to pass on the request and
response to the next entity in the chain.

A typical implementation of this method would follow the following
pattern:- 

1. Examine the request

2. Optionally wrap the request object with a custom implementation to
filter content or headers for input filtering 

3. Optionally wrap the response object with a custom implementation to
filter content or headers for output filtering 

4. a) Either invoke the next entity in the chain using
the FilterChain object (chain.doFilter()), 

4. b) or not pass on the request/response pair to the
next entity in the filter chain to block the request processing

5. Directly set headers on the response after invocation of the next
entity in the filter chain.
This default implementation simply calls the next filter in the filter
chain.
Params:
request –  The request to process
response – The response associated with the request
chain –    Provides access to the next filter in the chain for this
                filter to pass the request and response to for further
                processing
Throws:
IOException – if an I/O error occurs during this filter's
                    processing of the request
ServletException – if the processing fails for any other reason/**
     * The <code>doFilter</code> method of the Filter is called by the container
     * each time a request/response pair is passed through the chain due to a
     * client request for a resource at the end of the chain. The FilterChain
     * passed in to this method allows the Filter to pass on the request and
     * response to the next entity in the chain.
     * <p>
     * A typical implementation of this method would follow the following
     * pattern:- <br>
     * 1. Examine the request<br>
     * 2. Optionally wrap the request object with a custom implementation to
     * filter content or headers for input filtering <br>
     * 3. Optionally wrap the response object with a custom implementation to
     * filter content or headers for output filtering <br>
     * 4. a) <strong>Either</strong> invoke the next entity in the chain using
     * the FilterChain object (<code>chain.doFilter()</code>), <br>
     * 4. b) <strong>or</strong> not pass on the request/response pair to the
     * next entity in the filter chain to block the request processing<br>
     * 5. Directly set headers on the response after invocation of the next
     * entity in the filter chain.
     *
     * This default implementation simply calls the next filter in the filter
     * chain.
     *
     * @param request  The request to process
     * @param response The response associated with the request
     * @param chain    Provides access to the next filter in the chain for this
     *                 filter to pass the request and response to for further
     *                 processing
     *
     * @throws IOException if an I/O error occurs during this filter's
     *                     processing of the request
     * @throws ServletException if the processing fails for any other reason
     */
    protected void doFilter(HttpServletRequest request, HttpServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }
}