1 /*
   2  * reserved comment block
   3  * DO NOT REMOVE OR ALTER!
   4  */
   5 /*
   6  * Copyright  1999-2004 The Apache Software Foundation.
   7  *
   8  *  Licensed under the Apache License, Version 2.0 (the "License");
   9  *  you may not use this file except in compliance with the License.
  10  *  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  *  Unless required by applicable law or agreed to in writing, software
  15  *  distributed under the License is distributed on an "AS IS" BASIS,
  16  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  *  See the License for the specific language governing permissions and
  18  *  limitations under the License.
  19  *
  20  */
  21 package com.sun.org.apache.xml.internal.security.transforms;
  22 
  23 import java.io.IOException;
  24 import java.io.OutputStream;
  25 import javax.xml.parsers.ParserConfigurationException;
  26 
  27 import com.sun.org.apache.xml.internal.security.c14n.CanonicalizationException;
  28 import com.sun.org.apache.xml.internal.security.c14n.InvalidCanonicalizerException;
  29 import com.sun.org.apache.xml.internal.security.signature.XMLSignatureInput;
  30 import org.xml.sax.SAXException;
  31 
  32 /**
  33  * Base class which all Transform algorithms extend. The common methods that
  34  * have to be overridden are the
  35  * {@link #enginePerformTransform(XMLSignatureInput, Transform)} method.
  36  *
  37  * @author Christian Geuer-Pollmann
  38  */
  39 public abstract class TransformSpi {
  40     /**
  41      * For API compatibility not thread safe.
  42      * @deprecated
  43      */
  44     @Deprecated
  45     protected Transform _transformObject = null;
  46     /**
  47      * Set the transform object.
  48      * Depeprecated For API compatibility.
  49      * @param transform the Transform
  50      * @deprecated
  51      */
  52     @Deprecated
  53     protected void setTransform(Transform transform) {
  54         this._transformObject = transform;
  55     }
  56     /**
  57      * The mega method which MUST be implemented by the Transformation Algorithm.
  58      *
  59      * @param input {@link XMLSignatureInput} as the input of transformation
  60      * @param os where to output this transformation.
  61      * @param _transformObject the Transform
  62      * @return {@link XMLSignatureInput} as the result of transformation
  63      * @throws CanonicalizationException
  64      * @throws IOException
  65      * @throws InvalidCanonicalizerException
  66      * @throws ParserConfigurationException
  67      * @throws SAXException
  68      * @throws TransformationException
  69      */
  70     protected XMLSignatureInput enginePerformTransform(
  71         XMLSignatureInput input, OutputStream os, Transform _transformObject)
  72         throws IOException,
  73                CanonicalizationException, InvalidCanonicalizerException,
  74                TransformationException, ParserConfigurationException,
  75                SAXException {
  76         return enginePerformTransform(input, _transformObject);
  77     }
  78     /**
  79      * The mega method which MUST be implemented by the Transformation Algorithm.
  80      * In order to be compatible with preexisting Transform implementations,
  81      * by default this implementation invokes the deprecated, thread-unsafe
  82      * methods. Subclasses should override this with a thread-safe
  83      * implementation.
  84      *
  85      * @param input {@link XMLSignatureInput} as the input of transformation
  86      * @param _transformObject the Transform
  87      * @return {@link XMLSignatureInput} as the result of transformation
  88      * @throws CanonicalizationException
  89      * @throws IOException
  90      * @throws InvalidCanonicalizerException
  91      * @throws ParserConfigurationException
  92      * @throws SAXException
  93      * @throws TransformationException
  94      */
  95     protected XMLSignatureInput enginePerformTransform(
  96         XMLSignatureInput input, Transform _transformObject)
  97         throws IOException,
  98                CanonicalizationException, InvalidCanonicalizerException,
  99                TransformationException, ParserConfigurationException,
 100                SAXException {
 101         //Default implementation overide with a much better
 102         try {
 103                 TransformSpi tmp = (TransformSpi) getClass().newInstance();
 104             tmp.setTransform(_transformObject);
 105             return tmp.enginePerformTransform(input);
 106         } catch (InstantiationException e) {
 107             throw new TransformationException("",e);
 108         } catch (IllegalAccessException e) {
 109             throw new TransformationException("",e);
 110         }
 111     }
 112 
 113     /**
 114      * The mega method which MUST be implemented by the Transformation Algorithm.
 115      * @deprecated
 116      * @param input {@link XMLSignatureInput} as the input of transformation
 117      * @return {@link XMLSignatureInput} as the result of transformation
 118      * @throws CanonicalizationException
 119      * @throws IOException
 120      * @throws InvalidCanonicalizerException
 121      * @throws ParserConfigurationException
 122      * @throws SAXException
 123      * @throws TransformationException
 124      */
 125     @Deprecated
 126     protected XMLSignatureInput enginePerformTransform(
 127         XMLSignatureInput input)
 128         throws IOException,
 129                CanonicalizationException, InvalidCanonicalizerException,
 130                TransformationException, ParserConfigurationException,
 131                SAXException {
 132         throw new UnsupportedOperationException();
 133     }
 134     /**
 135      * Returns the URI representation of <code>Transformation algorithm</code>
 136      *
 137      * @return the URI representation of <code>Transformation algorithm</code>
 138      */
 139     protected abstract String engineGetURI();
 140 }