ExceptionTransformer.java

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

  18. import java.io.Serializable;

  19. import org.apache.commons.collections4.FunctorException;
  20. import org.apache.commons.collections4.Transformer;

  21. /**
  22.  * Transformer implementation that always throws an exception.
  23.  *
  24.  * @param <T> the type of the input to the function.
  25.  * @param <R> the type of the result of the function.
  26.  * @since 3.0
  27.  */
  28. public final class ExceptionTransformer<T, R> implements Transformer<T, R>, Serializable {

  29.     /** Serial version UID */
  30.     private static final long serialVersionUID = 7179106032121985545L;

  31.     /** Singleton predicate instance */
  32.     @SuppressWarnings("rawtypes") // the static instance works for all types
  33.     public static final Transformer INSTANCE = new ExceptionTransformer<>();

  34.     /**
  35.      * Factory returning the singleton instance.
  36.      *
  37.      * @param <I>  the input type
  38.      * @param <O>  the output type
  39.      * @return the singleton instance
  40.      * @since 3.1
  41.      */
  42.     public static <I, O> Transformer<I, O> exceptionTransformer() {
  43.         return INSTANCE;
  44.     }

  45.     /**
  46.      * Restricted constructor.
  47.      */
  48.     private ExceptionTransformer() {
  49.     }

  50.     /**
  51.      * Returns the singleton instance.
  52.      *
  53.      * @return the singleton instance.
  54.      */
  55.     private Object readResolve() {
  56.         return INSTANCE;
  57.     }

  58.     /**
  59.      * Transforms the input to result by cloning it.
  60.      *
  61.      * @param input  the input object to transform
  62.      * @return never
  63.      * @throws FunctorException always
  64.      */
  65.     @Override
  66.     public R transform(final T input) {
  67.         throw new FunctorException("ExceptionTransformer invoked");
  68.     }

  69. }