/*
 * 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 org.apache.commons.io;

import java.io.IOException;
import java.io.Serializable;

An IOException decorator that adds a serializable tag to the wrapped exception. Both the tag and the original exception can be used to determine further processing when this exception is caught. 
Since:
2.0/**
 * An {@link IOException} decorator that adds a serializable tag to the
 * wrapped exception. Both the tag and the original exception can be used
 * to determine further processing when this exception is caught.
 *
 * @since 2.0
 */
@SuppressWarnings("deprecation") // needs to extend deprecated IOExceptionWithCause to preserve binary compatibility
public class TaggedIOException extends IOExceptionWithCause {

    
Generated serial version UID.
/**
     * Generated serial version UID.
     */
    private static final long serialVersionUID = -6994123481142850163L;

    
Checks whether the given throwable is tagged with the given tag.
 This check can only succeed if the throwable is a TaggedIOException and the tag is Serializable, but the argument types are intentionally more generic to make it easier to use this method without type casts. 

A typical use for this method is in a catch block to
determine how a caught exception should be handled:
Serializable tag = ...;
try {
    ...;
} catch (Throwable t) {
    if (TaggedIOExcepton.isTaggedWith(t, tag)) {
        // special processing for tagged exception
    } else {
        // handling of other kinds of exceptions
    }
}

Params:
throwable – The Throwable object to check
tag – tag object
Returns:
true if the throwable has the specified tag, otherwise false/**
     * Checks whether the given throwable is tagged with the given tag.
     * <p>
     * This check can only succeed if the throwable is a
     * {@link TaggedIOException} and the tag is {@link Serializable}, but
     * the argument types are intentionally more generic to make it easier
     * to use this method without type casts.
     * <p>
     * A typical use for this method is in a <code>catch</code> block to
     * determine how a caught exception should be handled:
     * <pre>
     * Serializable tag = ...;
     * try {
     *     ...;
     * } catch (Throwable t) {
     *     if (TaggedIOExcepton.isTaggedWith(t, tag)) {
     *         // special processing for tagged exception
     *     } else {
     *         // handling of other kinds of exceptions
     *     }
     * }
     * </pre>
     *
     * @param throwable The Throwable object to check
     * @param tag tag object
     * @return {@code true} if the throwable has the specified tag,
     * otherwise {@code false}
     */
    public static boolean isTaggedWith(final Throwable throwable, final Object tag) {
        return tag != null
            && throwable instanceof TaggedIOException
            && tag.equals(((TaggedIOException) throwable).tag);
    }

    
Throws the original IOException if the given throwable is a TaggedIOException decorator the given tag. Does nothing if the given throwable is of a different type or if it is tagged with some other tag. 

This method is typically used in a catch block to
selectively rethrow tagged exceptions.
Serializable tag = ...;
try {
    ...;
} catch (Throwable t) {
    TaggedIOExcepton.throwCauseIfTagged(t, tag);
    // handle other kinds of exceptions
}

Params:
throwable – an exception
tag – tag object
Throws:
IOException – original exception from the tagged decorator, if any/**
     * Throws the original {@link IOException} if the given throwable is
     * a {@link TaggedIOException} decorator the given tag. Does nothing
     * if the given throwable is of a different type or if it is tagged
     * with some other tag.
     * <p>
     * This method is typically used in a <code>catch</code> block to
     * selectively rethrow tagged exceptions.
     * <pre>
     * Serializable tag = ...;
     * try {
     *     ...;
     * } catch (Throwable t) {
     *     TaggedIOExcepton.throwCauseIfTagged(t, tag);
     *     // handle other kinds of exceptions
     * }
     * </pre>
     *
     * @param throwable an exception
     * @param tag tag object
     * @throws IOException original exception from the tagged decorator, if any
     */
    public static void throwCauseIfTaggedWith(final Throwable throwable, final Object tag)
            throws IOException {
        if (isTaggedWith(throwable, tag)) {
            throw ((TaggedIOException) throwable).getCause();
        }
    }

    
The tag of this exception.
/**
     * The tag of this exception.
     */
    private final Serializable tag;

    
Creates a tagged wrapper for the given exception.
Params:
original – the exception to be tagged
tag – tag of this exception/**
     * Creates a tagged wrapper for the given exception.
     *
     * @param original the exception to be tagged
     * @param tag tag of this exception
     */
    public TaggedIOException(final IOException original, final Serializable tag) {
        super(original.getMessage(), original);
        this.tag = tag;
    }

    
Returns the serializable tag object.
Returns:
tag object/**
     * Returns the serializable tag object.
     *
     * @return tag object
     */
    public Serializable getTag() {
        return tag;
    }

    
Returns the wrapped exception. The only difference to the overridden Throwable.getCause() method is the narrower return type. 
Returns:
wrapped exception/**
     * Returns the wrapped exception. The only difference to the overridden
     * {@link Throwable#getCause()} method is the narrower return type.
     *
     * @return wrapped exception
     */
    @Override
    public IOException getCause() {
        return (IOException) super.getCause();
    }

}