import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * @inheritDoc
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {
    /**
     * If the actual input is an octet stream, then the application MUST
     * convert the octet stream to an XPath node-set suitable for use by
     * Canonical XML with Comments. (A subsequent application of the
     * REQUIRED Canonical XML algorithm would strip away these comments.)
     *
     * ...
     *
     * The evaluation of this expression includes all of the document's nodes
     * (including comments) in the node-set representing the octet stream.
     */

    Node signatureElement = transformObject.getElement();

    signatureElement = searchSignatureElement(signatureElement);
    input.setExcludeNode(signatureElement);
    input.addNodeFilter(new EnvelopedNodeFilter(signatureElement));
    return input;
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * @param signatureElement
 * @return the node that is the signature
 * @throws TransformationException
 */
private static Node searchSignatureElement(Node signatureElement)
    throws TransformationException {
    boolean found = false;

    while (true) {
        if (signatureElement == null
            || signatureElement.getNodeType() == Node.DOCUMENT_NODE) {
            break;
        }
        Element el = (Element) signatureElement;
        if (el.getNamespaceURI().equals(Constants.SignatureSpecNS)
            && el.getLocalName().equals(Constants._TAG_SIGNATURE)) {
            found = true;
            break;
        }

        signatureElement = signatureElement.getParentNode();
    }

    if (!found) {
        throw new TransformationException(
            "transform.envelopedSignatureTransformNotInSignatureElement");
    }
    return signatureElement;
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 *
 * @param input
 * @return  {@link XMLSignatureInput} as the result of transformation
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {

    Object exArgs[] = { implementedTransformURI };

    throw new TransformationException("signature.Transform.NotYetImplemented", exArgs);
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * Creates a Transforms element for a given set of algorithms
 * @param document the target XML document
 * @param algorithmsParametersMarshaller algorithm parameters marshaller
 * @param algorithms algorithms
 * @return the Transforms
 * @throws UnsupportedAlgorithmException if an algorithm is not supported
 */
public static Transforms createTransforms(
        Document document,
        AlgorithmsParametersMarshallingProvider algorithmsParametersMarshaller,
        Iterable<Algorithm> algorithms) throws UnsupportedAlgorithmException
{
    Transforms transforms = new Transforms(document);

    for (Algorithm t : algorithms)
    {
        try
        {
            List<Node> params = algorithmsParametersMarshaller.marshalParameters(t, document);
            if (null == params)
            {
                transforms.addTransform(t.getUri());
            }
            else
            {
                transforms.addTransform(t.getUri(), DOMHelper.nodeList(params));
            }
        }
        catch (TransformationException ex)
        {
            throw new UnsupportedAlgorithmException(
                    "Unsupported transform on XML Signature provider",
                    t.getUri(), ex);
        }
    }
    return transforms;
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected XMLSignatureInput enginePerformTransform(
        XMLSignatureInput input, OutputStream os, Transform _transformObject)
        throws IOException,
               CanonicalizationException, InvalidCanonicalizerException,
               TransformationException, ParserConfigurationException,
               SAXException {
        return enginePerformTransform(input, _transformObject);
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 * @inheritDoc
 * @param input
 *
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {
    try {
        /**
         * If the actual input is an octet stream, then the application MUST
         * convert the octet stream to an XPath node-set suitable for use by
         * Canonical XML with Comments. (A subsequent application of the
         * REQUIRED Canonical XML algorithm would strip away these comments.)
         *
         * ...
         *
         * The evaluation of this expression includes all of the document's nodes
         * (including comments) in the node-set representing the octet stream.
         */
        Element xpathElement =
            XMLUtils.selectDsNode(
                transformObject.getElement().getFirstChild(), Constants._TAG_XPATH, 0);

        if (xpathElement == null) {
            Object exArgs[] = { "ds:XPath", "Transform" };

            throw new TransformationException("xml.WrongContent", exArgs);
        }
        Node xpathnode = xpathElement.getFirstChild();
        String str = XMLUtils.getStrFromNode(xpathnode);
        input.setNeedsToBeExpanded(needsCircumvent(str));
        if (xpathnode == null) {
            throw new DOMException(
                DOMException.HIERARCHY_REQUEST_ERR, "Text must be in ds:Xpath"
            );
        }

        XPathFactory xpathFactory = XPathFactory.newInstance();
        XPathAPI xpathAPIInstance = xpathFactory.newXPathAPI();
        input.addNodeFilter(new XPathNodeFilter(xpathElement, xpathnode, str, xpathAPIInstance));
        input.setNodeSet(true);
        return input;
    } catch (DOMException ex) {
        throw new TransformationException(ex);
    }
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * 
 * @param element
 * @throws XMLSignatureException
 * @throws InvalidTransformException
 * @throws XMLSecurityException
 * @throws TransformationException
 */
public TransformsImpl(Element element) 
    throws XMLSignatureException, InvalidTransformException,
        XMLSecurityException, TransformationException {
    super(element, "");
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 *
 * @param input
 * @return {@link XMLSignatureInput} as the result of transformation
 * @inheritDoc
 * @throws CanonicalizationException
 * @throws IOException
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, Transform transformObject
) throws IOException, CanonicalizationException, TransformationException {
    return enginePerformTransform(input, null, transformObject);
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 * Method getTransforms
 *
 * @return The transforms that applied this reference.
 * @throws InvalidTransformException
 * @throws TransformationException
 * @throws XMLSecurityException
 * @throws XMLSignatureException
 */
public Transforms getTransforms()
    throws XMLSignatureException, InvalidTransformException,
    TransformationException, XMLSecurityException {
    return transforms;
}
 

import org.apache.xml.security.transforms.TransformationException; //导入依赖的package包/类
/**
 *
 * @param element
 * @throws XMLSignatureException
 * @throws InvalidTransformException
 * @throws XMLSecurityException
 * @throws TransformationException
 */
public TransformsImpl(Element element)
    throws XMLSignatureException, InvalidTransformException,
        XMLSecurityException, TransformationException {
    super(element, "");
}